{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"></ul></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 80
    },
    "colab_type": "code",
    "id": "P4eM9iEYBEPm",
    "outputId": "095b40b0-89f5-4be5-884c-397bbbd0d85c"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import torch \n",
    "import torch.nn.functional as F\n",
    "from torch import nn\n",
    "import scipy.io as io\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from keras.utils import to_categorical\n",
    "from torch.optim import SGD, Adam\n",
    "from torch.utils import data\n",
    "\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iWD-H5xQBEPp"
   },
   "outputs": [],
   "source": [
    "\n",
    "M=4\n",
    "NN_T = 512\n",
    "NN_R=256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a = np.random.randn(1,1000000)/np.sqrt(2)\n",
    "\n",
    "# a[a>0.9*np.max(np.abs(a))] = 0.9**np.max(np.abs(a))\n",
    "\n",
    "\n",
    "# counts, bins = np.histogram(a,1000)\n",
    "# plt.hist(bins[:-1], bins, weights=counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Al9ZMmg1BEPr"
   },
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.fc1 = nn.Linear(M**2 + 8, NN_T) \n",
    "        self.bn1 = nn.BatchNorm1d(NN_T)\n",
    "        \n",
    "        self.fc2 = nn.Linear(NN_T, NN_T)\n",
    "        self.bn2 = nn.BatchNorm1d(NN_T)\n",
    "        self.fc3 = nn.Linear(NN_T, 4)\n",
    "        \n",
    "    def forward(self, in_message, in_channel):\n",
    "        x = torch.cat([in_message,in_channel],-1)\n",
    "        x = self.bn1(F.relu(self.fc1(x)))\n",
    "        x = self.bn2(F.relu(self.fc2(x)))\n",
    "        x = self.fc3(x)\n",
    "        transmitted = x / (torch.sqrt(2*torch.mean(x**2)))\n",
    "        return transmitted\n",
    "        \n",
    "class Decoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.de_fc1 = nn.Linear(2 + 4, NN_R)  \n",
    "        self.bn1 = nn.BatchNorm1d(NN_R)\n",
    "        \n",
    "        self.de_fc2 = nn.Linear(NN_R, NN_R)\n",
    "        self.bn2 = nn.BatchNorm1d(NN_R)\n",
    "        \n",
    "        self.de_fc3 = nn.Linear(NN_R, NN_R)\n",
    "        self.bn3 = nn.BatchNorm1d(NN_R)\n",
    "        \n",
    "        self.de_fc4 = nn.Linear(NN_R, M)\n",
    "        self.bn4 = nn.BatchNorm1d(M)\n",
    "    def forward(self, in_message, in_channel):\n",
    "        x = torch.cat([in_message,in_channel],-1)\n",
    "#         x = in_message\n",
    "        x = self.bn1(F.relu(self.de_fc1(x)))\n",
    "        x = self.bn2(F.relu(self.de_fc2(x)))\n",
    "        x = self.bn3(F.relu(self.de_fc3(x)))\n",
    "#         x = self.de_fc4(x)\n",
    "        x = self.bn4(self.de_fc4(x))\n",
    "        decoded = F.log_softmax(x, dim=-1)\n",
    "        return decoded\n",
    "        \n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 357
    },
    "colab_type": "code",
    "id": "WnFI9COKBEPu",
    "outputId": "178fc28b-3f21-47a6-f428-672f5d618013"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch= 0\n",
      "epoch= 1\n",
      "epoch= 2\n",
      "epoch= 3\n",
      "epoch= 4\n",
      "epoch= 5\n",
      "epoch= 6\n",
      "epoch= 7\n",
      "epoch= 8\n",
      "epoch= 9\n",
      "epoch= 10\n",
      "epoch= 11\n",
      "epoch= 12\n",
      "epoch= 13\n",
      "epoch= 14\n",
      "epoch= 15\n",
      "epoch= 16\n",
      "epoch= 17\n",
      "epoch= 18\n",
      "epoch= 19\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "encoder = Encoder().to(device)\n",
    "\n",
    "decoder1=Decoder().to(device)\n",
    "decoder2=Decoder().to(device)\n",
    "criterion= nn.NLLLoss()\n",
    "\n",
    "params = list(encoder.parameters()) + list(decoder1.parameters())+ list(decoder2.parameters())\n",
    "\n",
    "\n",
    "opt = Adam(params, lr = 0.001)\n",
    "\n",
    "loss = np.array([])\n",
    "\n",
    "batch = M * 6400000\n",
    "ch_real_set = torch.randn((batch, 2,2))/np.sqrt(2)\n",
    "\n",
    "r = 1\n",
    "\n",
    "ch_real_set[ch_real_set>r*torch.max(torch.abs(ch_real_set))] = r*torch.max(torch.abs(ch_real_set))\n",
    "ch_real_set[ch_real_set< -r*torch.max(torch.abs(ch_real_set))] = -r*torch.max(torch.abs(ch_real_set))\n",
    "\n",
    "ch_imag_set = torch.randn((batch, 2,2))/np.sqrt(2)\n",
    "ch_imag_set[ch_imag_set>0.8*torch.max(torch.abs(ch_imag_set))] = r*torch.max(torch.abs(ch_imag_set))\n",
    "ch_imag_set[ch_imag_set<-0.8*torch.max(torch.abs(ch_imag_set))] =-r*torch.max(torch.abs(ch_imag_set))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# data_set = data.TensorDataset(train_data_set,ch_real_set, ch_imag_set, targets_set1, targets_set2)\n",
    "# training_generator = data.DataLoader(data_set, batch_size=1024*4, shuffle=True, num_workers=4)\n",
    "\n",
    "\n",
    "ch_set = data.TensorDataset(ch_real_set, ch_imag_set)\n",
    "training_generator= data.DataLoader(ch_set, batch_size=2048, shuffle=True, num_workers=4)\n",
    "\n",
    "\n",
    "for epochs in range(20):\n",
    "    print('epoch=', epochs)\n",
    "    for csi_real,csi_imag in training_generator:\n",
    "        csi_real = csi_real.to(device)\n",
    "        csi_imag = csi_imag.to(device)\n",
    "        csi = torch.cat([csi_real.view(-1,4), csi_imag.view(-1,4)], -1)\n",
    "        csi1 = torch.cat([csi[:,0:2], csi[:,4:6]], -1)\n",
    "        csi2 = torch.cat([csi[:,2:4], csi[:,6:8]], -1)\n",
    "        \n",
    "        label1 = np.random.randint(0,M, (csi.shape[0]))\n",
    "        label2 = np.random.randint(0,M, (csi.shape[0]))\n",
    "        \n",
    "        \n",
    "        train_data = 4*label1 + label2\n",
    "        \n",
    "        train_data = torch.from_numpy(to_categorical(train_data)).to(device)\n",
    "      \n",
    "        \n",
    "#         train_data1 = torch.from_numpy(to_categorical(label1)).to(device)\n",
    "#         train_data2 = torch.from_numpy(to_categorical(label2)).to(device)\n",
    "        \n",
    "#         train_data = torch.cat([train_data1, train_data2], axis=-1)\n",
    "#         print(train_data.shape)\n",
    "        \n",
    "        label1 = torch.from_numpy(label1).to(device)\n",
    "        label2 = torch.from_numpy(label2).to(device)\n",
    "        \n",
    "    \n",
    "       \n",
    "        transmitted =encoder(train_data, csi)\n",
    "        \n",
    "        \n",
    "        transmitted_real = transmitted[:, np.arange(0,2)]\n",
    "        transmitted_imag = transmitted[:, np.arange(2,4)]\n",
    "        \n",
    "        tx_real = transmitted_real.view(-1, 2,1)\n",
    "        tx_imag = transmitted_imag.view(-1, 2,1)\n",
    "       \n",
    "\n",
    "        rx_real = torch.bmm(csi_real, tx_real) - torch.bmm(csi_imag, tx_imag)\n",
    "        rx_imag = torch.bmm(csi_real, tx_imag) + torch.bmm(csi_imag, tx_real)\n",
    "       \n",
    "        rx1 = torch.cat([rx_real[:,0,:], rx_imag[:,0,:]], axis=-1)\n",
    "       \n",
    "        rx2 = torch.cat([rx_real[:,1,:], rx_imag[:,1,:]], axis=-1)\n",
    "      \n",
    "        \n",
    "        sigma = np.sqrt(0.5/np.power(10, 15/10))\n",
    "        rx1 = rx1 + (torch.randn(rx1.shape)*sigma).to(device)\n",
    "  \n",
    "        rx2 = rx2 + (torch.randn(rx2.shape)*sigma).to(device)\n",
    "    \n",
    "#         y_pred1 = decoder1(rx1)\n",
    "#         y_pred2 = decoder2(rx2)\n",
    "       \n",
    "        \n",
    "        y_pred1 = decoder1(rx1, csi1)\n",
    "        y_pred2 = decoder2(rx2, csi2)\n",
    "       \n",
    "        \n",
    "        cross_entropy = criterion(y_pred1, label1) + criterion(y_pred2, label2)\n",
    "    \n",
    "\n",
    "        opt.zero_grad()\n",
    "        \n",
    "        \n",
    "        cross_entropy.backward()\n",
    "        opt.step()\n",
    "        \n",
    "\n",
    "    l = cross_entropy.item()\n",
    "    loss = np.append(loss, l)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.07065833 0.04209033 0.02964421 0.03675348 0.03590487 0.02706455\n",
      " 0.02460732 0.02895533 0.02652942 0.02775077 0.02977785 0.02749916\n",
      " 0.02979133 0.02242447 0.01871136 0.022842   0.02971677 0.02128352\n",
      " 0.03118827 0.01760677]\n"
     ]
    }
   ],
   "source": [
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "colab_type": "code",
    "id": "yI9_517iBEPw",
    "outputId": "f86a9277-671b-4e1f-8505-0d5ed86d2b04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2048  4096  6144  8192 10240 12288 14336 16384 18432 20480]\n",
      "(2,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.ndimage.filters import gaussian_filter1d\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy.signal import savgol_filter \n",
    "import tikzplotlib\n",
    "\n",
    "\n",
    "qqq = loss\n",
    "# ysmoothed = gaussian_filter1d(qqq, sigma=0.1)\n",
    "\n",
    "\n",
    "# plt.figure()\n",
    "# plt.loglog(loss)\n",
    "\n",
    "# aaa = savgol_filter(qqq,,1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# x = np.arange(aaa.shape[0])\n",
    "# data = np.concatenate([x.reshape(-1,1), aaa.reshape(-1,1)], -1)\n",
    "# np.savetxt('open_loss.txt', data[::100,:])\n",
    "\n",
    "x = np.arange(1,qqq.shape[0]+1)*2048\n",
    "print(x[0:10])\n",
    "# plt.loglog(x,aaa)\n",
    "\n",
    "\n",
    "data = np.concatenate([x.reshape(-1,1), aaa.reshape(-1,1)], -1)\n",
    "plt.loglog(data[::10,0],data[::10,1]/2)\n",
    "\n",
    "print(data[::10,0].shape)\n",
    "\n",
    "\n",
    "\n",
    "np.savetxt('mu_mimo_loss.txt', data[::100,:])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "frohmjvYBEPz"
   },
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()\n",
    "SER =np.array([])\n",
    "num_iter=1\n",
    "with torch.no_grad():\n",
    "    for snr in np.arange(0, 24,1):\n",
    "        batch = M * 16*1000\n",
    "        \n",
    "        ch_real = ((torch.randn((batch, 2,2))/np.sqrt(2))).to(device)\n",
    "        ch_imag = ((torch.randn((batch, 2,2))/np.sqrt(2))).to(device)\n",
    "        r = 0.8\n",
    "        ch_real[ch_real>r*torch.max(torch.abs(ch_real))] = r*torch.max(torch.abs(ch_real))\n",
    "        ch_real[ch_real<-r*torch.max(torch.abs(ch_real))] = -r*torch.max(torch.abs(ch_real))\n",
    "        ch_imag[ch_imag>r*torch.max(torch.abs(ch_imag))] = r*torch.max(torch.abs(ch_imag))\n",
    "        ch_imag[ch_imag<-r*torch.max(torch.abs(ch_imag))] = -r*torch.max(torch.abs(ch_imag))\n",
    "            \n",
    "        total_corr = 0\n",
    "        for i in range(num_iter):\n",
    "            test_messages = np.arange(M)\n",
    "            test_messages = np.tile(test_messages, int(batch/M))\n",
    "\n",
    "            test_mess1 = np.random.permutation(test_messages)\n",
    "            test_mess2 = np.random.permutation(test_messages)\n",
    "\n",
    "            train_data1 = to_categorical(test_mess1)\n",
    "            train_data2 = to_categorical(test_mess2)\n",
    "\n",
    "            csi = torch.cat([ch_real.view(-1,4), ch_imag.view(-1,4)], -1).to(device)\n",
    "            csi1 = torch.cat([csi[:,0:2], csi[:,4:6]], -1).to(device)\n",
    "            csi2 = torch.cat([csi[:,2:4], csi[:,6:8]], -1).to(device)\n",
    "\n",
    "\n",
    "            test_data = 4*test_mess1 + test_mess2\n",
    "            test_data_set = torch.from_numpy(to_categorical(test_data)).to(device)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "            transmitted =encoder(test_data_set, csi)\n",
    "\n",
    "            transmitted_real = transmitted[:, np.arange(0,2)]\n",
    "            transmitted_imag = transmitted[:, np.arange(2,4)]\n",
    "\n",
    "            tx_real = transmitted_real.view(-1, 2,1)\n",
    "            tx_imag = transmitted_imag.view(-1, 2,1)\n",
    "\n",
    "            rx_real = torch.bmm(ch_real, tx_real) - torch.bmm(ch_imag, tx_imag)\n",
    "            rx_imag = torch.bmm(ch_real, tx_imag) + torch.bmm(ch_imag, tx_real)\n",
    "\n",
    "            rx1 = torch.cat([rx_real[:,0,:], rx_imag[:,0,:]], axis=-1)\n",
    "            rx2 = torch.cat([rx_real[:,1,:], rx_imag[:,1,:]], axis=-1)\n",
    "\n",
    "            sigma = np.sqrt(0.5/np.power(10, snr/10))\n",
    "            rx1 = rx1 + (torch.randn(rx1.shape)*sigma).to(device)\n",
    "            rx2 = rx2 + (torch.randn(rx2.shape)*sigma).to(device)\n",
    "\n",
    "            y_pred1 = decoder1(rx1, csi1)\n",
    "            y_pred2 = decoder2(rx2, csi2)\n",
    "\n",
    "\n",
    "            classification1 = torch.argmax(y_pred1, axis=-1).to('cpu').detach().numpy()\n",
    "            classification2 = torch.argmax(y_pred2, axis=-1).to('cpu').detach().numpy()\n",
    "\n",
    "            correct1 = np.equal(classification1 , test_mess1)\n",
    "            correct2 = np.equal(classification2 , test_mess2)\n",
    "            correct = sum(correct1) + sum(correct2)\n",
    "          \n",
    "            total_corr = total_corr + correct\n",
    "        ser =1 - total_corr / (batch*2*num_iter)\n",
    "\n",
    "        SER = np.append(SER, ser)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s8BtpL0ZBEP1"
   },
   "outputs": [],
   "source": [
    "ser_theory = io.loadmat('baseline/zero_forcing_SER.mat')\n",
    "base_line = ser_theory['SER'] \n",
    "\n",
    "np.savez('CSIT-partial-CSIR-SER.npz', SER = SER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 279
    },
    "colab_type": "code",
    "id": "LmgYf3kUBEP3",
    "outputId": "56e52534-b153-4d4e-dd34-7bfd9bae7c03"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(16,9))\n",
    "p1,p2 = plt.semilogy(np.arange(0, 24,1), SER, np.arange(0,27,2), base_line[0,0:14])\n",
    "plt.xlabel('SNR')\n",
    "plt.ylabel('SER')\n",
    "plt.legend([p1,p2],['MU-MIMO','Zero-forcing-transmitter'])\n",
    "plt.grid()\n",
    "\n",
    "import tikzplotlib as tikz\n",
    "tikz.save('ser_vd.tex')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.40660938 0.36571094 0.32238281 0.28098437 0.23639844 0.19475781\n",
      " 0.15789062 0.12135938 0.09028125 0.06445312 0.04334375 0.0280625\n",
      " 0.01714063 0.01069531 0.00621094 0.00348437 0.00185156 0.00142969\n",
      " 0.00097656 0.00086719 0.00082812 0.00059375 0.00051563 0.0005    ]\n"
     ]
    }
   ],
   "source": [
    "print(SER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "matplotlib2tikz has been renamed to tikzplotlib <https://pypi.org/project/tikzplotlib>",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-f855bd87e899>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib2tikz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mmatplotlib2tikz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"test.tex\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/miniconda3/envs/deeplearning/lib/python3.7/site-packages/matplotlib2tikz/__init__.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     27\u001b[0m ]\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"matplotlib2tikz has been renamed to tikzplotlib <https://pypi.org/project/tikzplotlib>\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: matplotlib2tikz has been renamed to tikzplotlib <https://pypi.org/project/tikzplotlib>"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2df3RU53nnv68B1UhyDRJjYn4KJBlX8cqKGTsYYzsGfBq3LOmP4K3TsyHZbYnPbh3i+qRZEm+zad26PT62S9yeg2mTFJ9knZg0bbwkPjVgbBAEYmFjamRkNCBFYIKHkYzRjzBIvPvHzHv13jv33rkzc2fm3pnv5xyO0Myd933vO7rP+7zP+/wQUkoQQggJL1eVewCEEEIKg4KcEEJCDgU5IYSEHApyQggJORTkhBAScqaWo9NZs2bJpqamcnRNCCGh5fDhw+ellBHr62UR5E1NTejq6ipH14QQElqEEP12r9O0QgghIYeCnBBCQg4FOSGEhBwKckIICTkFC3IhxNVCiJ8LId4SQhwTQnzDj4ERQgjxhh9eK5cArJRSDgshpgHoFEK8JKU86EPbhBBCslCwIJep9InD6V+npf8xpSIhhJQIX2zkQogpQogjAN4HsFNKecjmmg1CiC4hRFc8HvejW1IBDI4k8exrMQyOJMs9FEJCiy+CXEo5IaXsADAPwG1CiJtsrtkqpYxKKaORSEZgEqlStncN4PGXjmN710C5h0JIaPE1slNK+YEQYg+ATwJ428+2SWWyLjrf9JMQkjt+eK1EhBAz0v+fDuBeAMcLbZdUBw11NfjC3c1oqKsp91AICS1+aOTXA9gmhJiC1MLwgpRyhw/tEkII8YAfXitHAXzMh7EQQgjJA0Z2EkJIyKEgJ4SQkENBTgghIYeCnBBCQg4FOSE5wEhUEkQoyEloKYdQZSQqCSJlqdlJiB8ooQoAX7i7uSR9MhKVBBEKchJayiFUVSQqIUGCphVSNIpt+mB4PyEpKMhJ0aA9mZDSQNMKKRq0JxNSGijISdGgPZmQ0kDTCiGEhBwKcuIKA2AICT4U5MQVHlgSEnxoIyeu8MCSkOBDQU5c4YElIcGHphVCSkTYzxvCPv5yU8z5oyAnpET4ed7AhGHho5jzR9MKISXCz/MGJgwLH8WcPyGl9L3RbESjUdnV1VXyfgmpFAZHktjeNYB10fnMNVNFCCEOSymj1tepkRMSQngITXRoIyehhAdvhExCQU5CSVAP3rjAkHJQsCAXQswXQuwRQnQLIY4JITb6MTBC3FgXnY9N990YuIO3XBaYfIU+FwtixQ8b+TiAR6SUbwghrgFwWAixU0rZ7UPbhNgSVBtxLp4J+XqelMNjJSxU6yFwwYJcSnkWwNn0/y8KId4BMBcABTmpOnJZYPJ1R6MboDPVusj56n4ohGgCsBfATVLKDy3vbQCwAQAWLFiwtL+/37d+CSEEqHyN3Mn90LfDTiFEPYB/AfAlqxAHACnlVillVEoZjUQifnVLqgTahc04zUe1z1O11nH1RZALIaYhJcS/J6X8kR9tEqITVC+VcuE0H+Wap2pfQMpNwTZyIYQA8C0A70gpnyp8SIRkQruwGaf5KNc8VattOigUbCMXQqwAsA/AfwC4kn75q1LKnzp9hiH6hKSoFJtupdxH0ClaiL6UshOAKLQdQqqRStFkg+oOWi0w1wohZcRPUwi14uqFIfokMJT6wCyX/oo1Nj+9LHggXL1QkBNbqqFwQS79hUFIBjVtASk+NK0QW6qhcEEu/YXBayZIdmqaeUoLBXkACcJDUA7BVWpBlEt/QRKSYaBSDnHDAk0rASQI2/hqjZDzkzBGX/o1Npp5SgsFeQDhQ1B8ChVYXj4ftOhLL2w70IfHXzqObQf6CmqHikBpoWklgHAbX3y2HejD5t0nMJqcwMP33pDz572YDrxGXwbBlDaJtPwkYYCCnFQphQksL8LYaUG2vh4ke/L65YtQWzOVu8GQQUFOqpJCBZafwtjtYLnU2rpfu8Fg7TIqH9rISVXi1YabzRau3l/dNjvvcw23sdjZ08NwiBrkc4BKhBo5IS5k07Sd3vdLI7XT1p36DJKJJgx+95UEBTkJHF6EYKm27tkEktP7fglVO1PHuuh8jCYnMJocx+BI0rj/IAlPHtiXFppWiIkgbM+9bMuDsnV3Mos4uZDG4sP4/Hd+jlh8uKA+a2umYPPuXtP9F9PlLwh/F8QZauTERBC25140y1IdEOY7H04a6WM7urGnJw6gG9/5/G15j6vU2ncQ/i6IMxTkxEQQtudOQlAJ6NVts7Gr+5yjoPZT6GSbD+uikW0ReXRNG4BuPLqmraAFp9SmiyD8XRBnaFohJoIckacE9GM7uvH4S8fxyAtHbLf6+UTGKtNBLD5smBB0QQvA1rRgNfE4mXxU+zNra/Cdz9+G5kh9xrV+mi/8NoUE+e+CUCMnPlLsA0glUFe3zQaQMlFs7xrwRTNVQvXgyUTa9JFCafb6//X+rJpqtsPPgycTePL+DjTU1WRc6+dOgqaQ6oKCnPhGsYWH0goHR5JonzcD7fOutdW61ThGkxOorZniaWHRF4lli8+Z2l3dNhsvHnkPG1e15GxaiMWH8diObjy0shX3LImYFh+recRP8wVNIdUFBTnxjVIJj+1dA9i8+wQ23XejrYBW/Y8mxz0vLLpQbb673nj9C3c349nXYo79WRcv6++Th5vAk/d3mEw1hZBt95OLDZ1RmOGHgpz4RqkO4LItGLrm7kfeELe8KtlMK/rhpnV+rIe3o8lxbN7dCyD7wuNl9+MmoPX3aIYJPxTkxFdKod15XTD80kqz5VXR37Ne2xypd3QztNrlV7Q0YuOqVt8qFrkJaP09L22VUmvnDiF3KMhJXjg9bMXQ7krxYOcybl3wFTI2u8PbO1sjntrxski5CWj9PS9t5fq9FjIv3CHkgZSy5P+WLl0q8yExfEluebVXJoYv5fV5kh0vc5wYviQ/9+1DcuFXdsgtr/bm/Plsffe+f9HUxpZXe2378pN8x+11bNnaD/rfdq7jK+Q7C/pclBMAXdJGpvqikQshvg1gDYD3pZQ3+dGmHVypi4+XOd7eNYA9PXHcsySSoe0VYie3cwH8wt3NOR2i5qsJ5jtuN/s5AM926GKdL+QyH7mYl7JRyME387Tkjl+mlX8G8PcAnvOpPVuK4RVBe5yZXMPj/ZwzJxfAXB7sfBd7vxYAvX8AOdmhi0Eu8+GnokRhXGLs1PR8/gFoAvC2l2vzNa0Ug3y3gEHa/gVpLH6QGL4kn3r5uHzq5Z6c78kvE0m+7eifK6U5xaktu7l0u7aS/o4qERTTtOIFIcQGABsAYMGCBaXqNiv5akpBMvMEaSx+kPITT7nh1dZM8SVZlUIF6Dy6pg3NkUl/cb+iLK39u7kGPvLCEezpiZuiPfPFabypTIlT8fhLx425dLu2Ev5+qpGSCXIp5VYAWwEgGo0GprKrX7bRclLuseRrlnD6XCrf9jgA4fs9OWUfzBZl6WT7Vomyth04BUBg/fImTznU1TlDc6TOl1QDTn8DgyNJjCbHTW6N5f570aFp0x/ofpgnQdJeyj2WfLVXN81w/fJFRck1rgfo5MK2A33YvPsERpMTAGD8/+F7bzDtIMYuT+Crv/Ubtm3Y+W7f2tSAZ145kXZBzB+nvwE1to2rWk0CsxjVjPKh0naT5YKCvArJ9uDm+mDnq+G5fc7uAfdD4KgAncGRJJ7e+S4AifXLFxntqT5UlKUyewBqEzm5mezqG8TgSBLrovPx/M9/gb7EKI6duWC8bx2vne/2s6/FsKcnjvZ5ZwAIABJrO+a6punNBdVnYvhSevEZx8P3LjFdU05hGqTdQZjxy/3weQCfADBLCHEawNellN/yo23iP/nWoXQi3x2B2+fsHnC3ceUq5FW+FgAYS06gsf7XTG6CG1e1YkVLI/b0xLHtQB/WdszF0dMXsLZjLmbW1uDo6Qsmk8i3PnerYXtX6Fr8w/fe4Fi2DQBGkxPGeFTbuST9ckL1mVq0gNRiYaacwrTcu8lKwRdBLqV8wI92SGnI9uCW+sG2szG7CT19XJMa9KQg9CIY1kXnY9+J8+jsPY/usxfR2XvKpg+Jzt4EDp48j4Mnz+PQqSG0zzuDh+9dgifv78C2A31G3czmSL2RFGtmtCYteDO1eH3MumY+mTc8pZEvW3zOlPRLLTL5CvX1y5uMRcEKhWn4oWmlCsn24BbjwXbTmL16qdiNa1KDbsmpmERDXQ2++cDHjKRVP/j5APadiGN122yjj/XLFxna8STCuBcA2Ly7F7U1U229QdYvX2SbtMtuZ9FQV4OH773BuKb57vq0cBcYTY4b2r3+mVzw+p3y8DGcUJCTkuBmFinESyXX4CSr9wkAzKytwYn3L6KzN4HHdkx6szTU1aQ171MYu3wF06ddhbUdcwy3QevicWtTA5ojdbi1qcH4vJ3wdNvxWMd39PQHtn15vc9ULvWU/d3No0bh9D1RwAcbCnLiO3YPvZvwSmmjSzJe9yI8ctU09VSxwGTkpZs3S23NVKxfnhqDOpxsjtRhbcdcky/6M6+cQCw+gidf7sFdN0Qcx+02ZmtkqEqFoB/IesEu3YEyrbjNqdP3RO+SYMOanVVELnUcC6n5aFe3Mp+aj041LfW6ml7HPymIBDbddyNWt83GaHLCqPqjvFlm1tbYfk6NYV10Pu5ZEkEsPoJd3edMfT60shXNkTo0R+rx+EvH8cXn38Cf/9vb+MN/PIg3+oc8zee66GS9UaXhP7Sy1VOeFL39ddH52LiqBa2zr8GGOxcZfuRONUUVTt/T6rbZuGdJpGA3SVIcqJFXGNls0aXIu+HXYalTtOULXQOIxUcwmhw3bNDZ7nV122wcPJnA2o45mFlbY5hHrFV/rJ/T87/89U/eQVf/IABgw52LMu7v3948g1h8BEsXzDTKunX2JgAAv/zhW4jFR4x2ndC19UdeOIJYfATPvHLCMae507hVROfm3cex6b4bjTbVPNgJZLe/nV3d57CnJ45li8+ZKih5gWaZ4kNBXmFks0XrP90oJOOgF3NHPmaTddH5hqngniURAMLRnqtr24BZEAFwzN5ovW/d33vrvpPGdYnhJKbXTMX65U0AVEbI9wEAP+8bxI/+xx3YduAUzl74FX5+ahD/+7fb0HPuYk6Lm525xy0aVv/p9JqbQPbrb8cKzTLFR6TysJSWaDQqu7q6St5vNVAO7efZ12J4/CWz5peNp3f2pCMOW2zt405YDwO3HejD0EgSJ88P4xufugnNkXpjPBtXtZpc7pxC7L0Qiw/j4e+/iZPnR1D/a1Pxyw8vAYDRx+MvHcdnly3E/th5PPHpm3HLwpk5z42X7y6fufbSh9c0A/lAjdw/hBCHpZRR6+vUyCsMJ23Yr7zUduSnrQnLT29Y76+2Zgo27+4HAMPjZDLIxlx82UsyK52UcOuD8gM/euZDAEDH/BlojtRjfyyBoZFL6OobwYa7FuPBu5vxF79zk2GvXhfNrOnphhfNNde59rpbUi6gTgWtC4F+6sWHgrxKKKZ9PJ8H1S1AReFlQVkXnY/EcBLdZy8YJgg/ii/r2QmBlOb92dsX4rWeOP703iVomlWH7V0D2HfiPPbHEqiZepUxRuv8qbEo4e52L0DKju10ba5zrcbidp6g970uWlj5Oh1q4qWDgrxKKJZ9PF9yqRM5me8k0yTSUFeDr/52ZpKqfISI/pltB05hT08cH180E8sWN2L98iZs7xpA/+AoXu8bxC0LZxqHqNbQfOUXP5qcwOBIEg11NUZAT2I4icb6Gqxum23Kp1KsqvZ6CgC3KFH9+1Dmm0LT69I2XjooyKuEXDS5cm2FrcJ3ddtsvJBO96r7gNslfrJ+PpsQsbO1H+4fNLxMlMln2eJZRsSl3QKn3BZ19BzgR09/YEq61X32Qjrs31zObtuBU8a9rV++KKOffDHvTqZ4mhv9UDlbel23BbOcOVyqDQpyUlT0CMNsGf2sAmZX9znE4iOGd0nKXg3odnUn4Z3SiieMXChu7ol6kJDuyWI1/dgtcE6CTF+EUuMW2LiqxchsqMrZKTPK2OUrxr0VYyHV28wmYPWIVn1XYYfbokDbeOmgICeeycdcYfX9Brwf5FnD7+3s6nY5vtX1ypsESEVn6ouJfq1aIFa0NJpMCdmiIHU7emI4iRPvXzQqD+mLECCNg8SZtal2ZtaqrIQp750Ndy7KKQTfC07flxcBa7eryCUSNGhUur2egpx4xmseDl0LH01O4I7mRuyPJWz9tnWsAsbtd70PwJzjW6GCX8YuX8Hm3ceNbIcqrexkcizzAqEOGr2k+1X+6Mpk8ovBLmx/cHmGgFMHjZOHj6kUtWPJlCY+PZ14y4l8csgXmtPdi4klLFp3pdvrKciJK/qD76R9WR8SZe/d+24c+2MJbFzV6ph7xM2v2U3gWG3Kdteq4Jf2eddi0303IjF8CZ2956Hs1Xof1oM+/T6dFh/9/aHRJDY814VYfASPvHAET97fYdimrXb/gycTGEun3d24qtWTJp5PDnm78eci0BrqaoygpFubGrJ63ZSKfLTrsOwc8oWCnBh40eq8ZfNL2bA/Ovda1+RRdu1ne32SVB9jySsmN0G7upvKpPJfbltgFJBw6kMPYbdqm3b2fj0N7fYHl+OLz79h2MVVGThdAx9NTpgWF7989e3e95rT3Q21GAKwneNykI92HZadQ75QkBMDr1qdFetDopsqvGzf7drP1q/qQwlG3Wxj1bSVHdrq7WLXx4tH3ksL2vcMbxW78m92Qq2hrgZLF85Me75IU9uq1JqyhavFwCt+5ZDPVaDpi+GyxecCodFWunadDwzRJwZhPBCyG7M1jP3pne9i8+4TWNEyC9984GOu5p2/29mD5w7+Ap9dtgB/8Tv/ydSeCsdXQtjOE8dpDv/6J+9g676TmHPt1Vhz8xxMn3YVNu/uxT1LInh0TZtvNTrzJYzffTXCEH2SlXJtP2PxYXz9x8fQdv01ePATLTmnEFC2aFVM+e4brjOlXF2/vMko0GA9tLNGcJ48PwoA6Dk37Bhmr8wrj+3oztDMneZwes0UAMB7F36FrXtPYuOqViNDIpDZjtd79/petnYq/TCw0qEgJwDKq5E9tqMbnb0pj5IT7w87RnEq7IROKldIqhTa4f4hdPYmcHnibXzzgVsMv2g9AEhvS5lmVrfNRmI4lQyr7fprbM8GlHb+7N4YBkcuO5p0rGNev7wJY8kJvHV6CDfPn2nKmri6bTba553BaHICsfiwq3buJnD1A+Bsicjc0vUG5VCTeIeCnADw1z0r10Xh0TVtuDxxDMnxlL37kReOoPW6emzdd8pWKFk15FTa2nFsuGsxIIG3Tg8BADp7E/ji82/gT+9dgmdeOYH1tzfhkReOGL7e1ra2dw1g675TuGdJxDgYtQq2ddH5+O7BfgwMjWHujKvRPu/ajDlUB5v6/TulElBzrftsu2nnTvbhwZEkDven7vtw/weuQTx27ejpegtxWSTlgYKcAMh+gGT3MDs94LkuCs2Renz3jz5uMnNcnkid3ew7cR5dfUP44zsXY9vP+gwhrAsZvUgEABw6NYT5M6djYGgMnb0JnB46gr7EKI4MfICh0ct46/QBbH9wOWbW1qTqcSavYMurMUCkgoJUvm47wdZQV4Prr70aA0NjuEoIU/FlVdFnaDSJzbv708m8PvRkMvJ6qOhkutl24BQ6exNoaqxFZ+95kwkpV99x/SdQ+T7YlQAFOQGQ3T7uZM6wS66Uj1eBEjaPrmkzQtd1G/Q7v/wQgyOXjYAbFXikhLg12CgxksTWvScxfdpVWDyrDn2JUdzVOgv7es9jcOQyHtvRjWWLG031O4FU5Z87W1NtKU1flUlTPP777XhsRzceWtmK1/sGjfdUzc6P/PrV2HTfjdh3IlUhqLP3vOH2qEwpekFkNZduaQysuWGsglkFFt3VGsEDt03PKoidhLMfLouk9FCQE0/YPcxOkX/KBOFVgweALa/FsHXvSSRGkvjqb6VMEE/e34Etr8Vw7MwF/PGdi/GXP+lGLD5i9KXbtx9d02ZyOVR9DY1eRlfa5DD716/GP332Vnz5h29h/e1NeHNgCBvuXAwAeOv0Bzh0atAUYfnsazHbHN16oixVQAIwV/RpjtTj1qYGnB46grtaZ5miOvV0BbXpQ1BroWSrMNUFr7pev04dps70KIhzEc6V7oNdCfgiyIUQnwSwGcAUAP8kpfwbP9ol2SmV/dLpYW6fdy3a583IGu3p9Jri2JkLpp+qTyXUB0eSWNN+PQBh2K318Hxr2w11NfjP7XPw3MF+NDXW4uiZD9F99iKm10xBLD5iLArKRfGN/iF8+Ydv4e4bIhkpBhLDSTy9s8dUyd5u3q2ZEF/vG0RfYhQP3FZrLG5KWK9oacTShQ2Gdr5xVSvWdsxxNKu4CeNUwWWJjatasX55k6diErq3Dw83w0/BglwIMQXAPwC4F8BpAK8LIV6UUnYX2jbJTinsl262cFWuzfp+rlrgX/zOTaa83nbucUo7fvHImQzvDLu2v3TvDZg7c7rJTLN04WRhZN0co8wiz7xyAssWN2rJtqYY3jDKFm51WXRKkzuanMCGOxdhNDmBN/qH8MwrJ/DQylYsW9xo3Jeu9TdH6k11NAdHktjyai+6z17ENz710YyoVT3ro75zsDuwdIL278rAD438NgC9UsqTACCE+D6ATwGgIC8BpbBfqqIIKtmUtW9VtEC3lbtpgXZYtVkn97h10fnY8loMAHDw5CBi8WHD3ry2Y06GJqoEnbK9O9mYdbOIylCorj0zNIa9J+K4tanB+OyenjiaI3WOOUiUO2RD3TQMjlzGjqPvIRYfQXL8Cu66IZIxh3bfn/KiASbL2NnNj7WNXP4maP+uDPwQ5HMBDGi/nwbwcetFQogNADYAwIIFC3zotjrIZjopjf1SWn6a+x4cSToG3OSLnvNE7wsApk+7CgBw6NQg/vzf3sb+WKoYhJ3rnpPGaR2jWkjs5ntgaBR9iVE8tfNd3Nk6yxjbnp44nnnlBPb0xG0PfJUtfGFDLe5onoVrp0/FLwZHPWvA66LzkRi+hO6zF00ViNR7+k+dMBQRIf5SssNOKeVWAFuBVIh+qfoNO0HY+q5fvsix9qXV28SrZpctQlGZQpYtPmeYG9Rn1nbMRSpplsTY5SvYH0vg44sa0Dr7GrTPu9biXz6BjataPI/Lbr6Vtt56Xb3xngowSi003cYipps8nvj0zfjyD9/CHc2z8NzBfkM7b47UGXb+0XQWxBe6BvDEp282vGDUjuKrv91mO05dAOdiSskGfcbDiR+C/AwA/SmZl36N+EAQtr5uWps1CMYrbguU7o3i5Eanamiu7ZiNxroaI6GV7mGizBu5VIa3m29dW1duhPpupH3eDGMBsXqXxOIjWNN+vWGXb47UYetno9jVfS6dv6UFzZE6xOIj+PIP38pafMNKPouVG0FQHEju+CHIXwfQKoRYhJQA/wMAn/GhXYLibH1j8WHjYFFFOOaLEh4qu5+X8HD9c9k8NHQBbI3C1AVOqiblVIs2nukDbodd7hY7VD7xLz7/phHkY10s3A559T5mRlP3tbptNoZGLmPiisSXVrXiR2+eMcxJduOztqP6T1UiKpwgKA4kdwoW5FLKcSHEnwD4d6TcD78tpTxW8MhI0ZgMtOnOKBycK0rwpRJWAXo9TSC/cmNu740mx7HtQB/WdswBkBKEKlmW7h5o9eRwMxnkkqNEzwuj5za3hrornP6vz9tzB/sBAD9680yGOUndi5MPuZMvf77QZh5OfLGRSyl/CuCnfrRFio/uoeEXdvU0AW9bdV3IDo0mTbsFa3FlFYmp+vri82+mq/5MugcC5pB33RZtPw5h+Zk5vm0HTgEQeGhlKy5PSLRdf01WDd4bqeOiO5obbc8ZdNOJ7nOuLxx2CcH8ypJIwgEjOyscL4Er+bRhxU6geTVvTNrZx7Hj6Nm0nTi1W9Bt8EAqhH66Vv9SCfH5aX9x63gmc4m3GBV5rPeztmMOjp7+wNDyrSiNHUgtIN/9o0mnrHxL1SncDpLV3CjTza7uc7aRpnZzn+0MgnbwyoKCvMLx46HNVat2Mm84ofujx+IjaI7UGbuFyffGjeAjdai6Ljofrxw/h0OnhjAwNIZd3ecwM1pjGofV9LG9ayBDO7erCmQmpamvaJlliird1X3OGJd1btzmzK5knFMgj5vN3Q2vZxCkMqAgr3D8eGi9tGEnuLJ9zlqSLXVgOVmBZ2Z0MrBIHWaq4CPVz7LFs3Do1BBWtJjzmaj37dz0dO08hb2fvBqjHv6uJwrb0xM3FU/2UqhanytrbhXrZ/RDabUQ5uMf7iVkn4QbCvIyUc4cKbn27eXB14VQyqbcB+sBpBUnoetUY3M0OYExi6udyh5orZHppImOJscBCNO9u5k3rLsK3fbePu+M0a6dRm2tRKTmXAUU6eH6QOY8+3Uone+OioQHCvIyUe4cKYX27fbgK7suYD6AtH5WT3qlv65Sso5dvoKnd/Zg7PIVdL93IV3UOHUwqFLANtTVoLZmCh5/6bjRl+rP6maZunZq+topGeXZVAIp3eShoitfOf4+EiNJPKi1b23LbhGxFm5WpLxTGl3n369Daesi6/Y3YVcUgwQfCvIykavJIx+NyUlge3mwnVDCUVXwUW1bc3+kDielq2nBOi71+sZVrfjs7QuNNLSKFS2NkBLYH0tgfyzhKkAB4Os/PobO3vO4PHHMOKDMx+Rx4v1hHDo1iEOnBtGoac25CMgVLY3YcOdiJEaS+FVy3LC3K/TFTc8ds2xxo5H7JV+8RIHqZxE8CA0fFORlIlc7ZT5atJugcXuw3YS72u5fnpAmO7M1iOfhe29wbEeZOKw1KpXJYW3HHGx4rgtDo5dx9VSBtjnXIrpwJh78RAsAGFV9RpMTRkkzuzlpu/4adPaeR9v11xivOV2ru/mt7ZhrcgN8dE0bRpP/AUDaesZY51HZ6pVGrxaGaVOuMhYIANjVPekvbreIZCv7lg9OC5n1LIIHoeGCgjwkFHpoabcQOLkHui0a1uIJCrtiElYtXX/PWqNy3wm4TikAABQJSURBVIk4AIHO3vNon3cGdzTPQmLkEj4YHccbv/gAv/nRj5hs2iqNrDID2C0YD36ixRS044ZyMUyFzJvTyTZH6rHyxuvw+EvHTcJXR/9+rPOn52Vpn/cexpLjhgul9XtY2zEnbXsXrvnJ8yWbAsGD0HBCQR4S3B4wL7Zwu4XAyT3QbdFw80F3Sz2rBOXed+N45jO3mA4NVdIpAOlQc4HnDvZjRcsstF1/DabXTDW5/aldQVNjLRLDl/B3u97Fcz/rx5kPxjB3xnTP3hnm0Hf3oKBsC6m+kFlt//p7yq5vF+ikcpLrB7x2i4bbfZTDrl3u/gkFeUXgZgtXJgzre+p9/aciX63MLfWsEpD7YwlsO9BnOlB7dE0bkuNvozlSj6unXYWx5ARWtDSis/c87kyXSVMauDI9NNRNQ19iFFv3ncLChloAwGs9cfQPjppSymY7lH38pePY+24czZF6fHxRA8aS44a5xprjBACGRt1C/TPztk8edqZ819XYsi2yuVDuAJ9y908oyMuC3xqMm0C289LQ3/fzwdvVfc42VwiQchMcuzyBY2cuYMwSkLOr+xz2xxL45Ye/MrL/bVzVahRBVtkQmyN1eGhlKwCky6XNwtKFM3D3DdcZ1XdUfvAvPv8mli6cAUA4huavbpuNF7oGjMNTIJXjXJlj9CpAgLmu5mhy3LAlT36Hmf7okwe4LUYGRPXdp8rIXcK2A322mnohGRvzpdz9k/ygIC8DfmswdvZphZtLXLaHNVvlduu1ur3d7rNIe5w0R+pxz5KIyQShBOQdzY2INjWYBFti+BKaGmsRi4/g9b5BU24RNRZl7nny/g5DAHf2ns8I/tHzpgASsfgI7mhuRHOkHj3nLuJmLR2tnkp3aDRp8v22BialAodgBA45zb/5nEAvIzclw/unFMUh7ErqlbJ/4g8U5GWgGBqM0wNofci81Ju0axPIrNxuvVa3t+tBPWpXsKKlEQBw8vwwOnsTaJ/3HlRxiNbrUkUhrAFE27smy50plz2n3CYqCOnRNW1G23btKX/uFS2NpojN5w72Y+WN1xkLowoeAiZ3G+3zZqC2ZgrWdswxJQlT7Vrrl7plQ9T7sPP+KQXWzI/UrsMJBXkZKIYG4/UBtGqaTjgVLHD6jH54+exrMYxdvpJ+Z1JI3drUgGlTUiaQO1sHM4Jk7HKyrIvOx95349gfS2DpwhlGQQYg0wddD0Ky5kxR/u8PrWzFxlUtONz/QdoGH8mI2FSHqkdPXzB5xgCZftZ6EBEAJEaS2Lz7uGEnd9v9pNw0l2S85uffRvbdl/mQl9p1OKEgrxC8PoBWTdMJdXC3cVWrpzwfbtkG9ff0iEZljhi7fAXTp11l6+/eUFeDZz5zS8aho3VBUTbnsfThrjqwVChPF1X8+Buf+ih2dZ8zBPe66HzT+JWpx7rgpcrMwejDuhN6emdP+sqUnbwQM1o2IeyUfEsnW/9O6YdJuKAgrzKyHYBOhslPpF/JrbyqNTDI6T01lvXLF5mElTVAyU6Y2QkkFYT09M53Dc1c18pVUI+1+LG1P7s8KNZx6fNnvSdr3pZCTBV2fvi60HaKRHWbc1KZUJBXIW4PtxIOdzQ3ZhzcecFtZ+CWN1vl+Li1qcF0EJq7RmufybA5Uo/amikYGBozFT+29jfpedOYYc9WP9XB5+q22UUNsNHNPVb3S+v7ToFD2fr3Or/F9BWnH3rhUJBXGdkeGt2D5K4bInkVS8jlemUS6eobxP5YwnDRUy6Mum+6l/aURmxXAu6hla34xeAonvj0zYat3dqfF9/6bQdOpQ8+z2TYuIvhU/3ikTOGmUevIqSPyUvgkB25nK0Uy1ecfuiFQ0FeZWR7aBrq7EuHeflsrn2p/mprpqTdEuuw/vYmAMjQkNvnnTEOH63t2QXu/OD1AWzdexIAcPT0BTy6pg3PvHLCcGF00ma9pf1NnS8cPDmIp3f2mDxjCjFlWO9DaeEb7lpsCHFr+gAvbbkturmcreg//cQaSEZyh4K8yijkgXT6rFtyLC996buAbT/rs9WQR5MTRlCQ9YHXbcXt82Zg8+4T+PiiBgCpEnAqp7d+eOnme2/FuiCtX95k5Ig5dGrQlKo3X1OK1S0UgDHe6dOucgy08jrmQimmN4tbIBnxBgV5leHlgfRL8/b68Ou7ACcNeXAkicP9g+jsTeDFI2aThr4QtM+7FpvuuxFnhkZx6NQgbl/cgJbhpHF4qfuhe71Pu9QDT97fYfit+6GlOrmFqv/nmpEwTIecYRprUKEgDwmlPBByerBU8EhiOInG+hqTZmt3vU62IsVKSM6stRf+DXU1WLqwIV1cQmS0aY32TNnHgfcuXEJn73nj8NKabtZu3NaxKo0R6DZyuCgvGS/36OUaO28ffceQqzasL4DKvTKoB4n0XS8cCnKNIJ+el+JAyFpDM5OUAO0+O1mtx2qesNp5ldaqcp7oCa30+3JzoVNYq93bZVtUfStvm7HkBJYunGHrDugkQFS7+06cx9KFM7C2Y+6k6Ue7H5VGwPo5t3vIZfeSy3dezGpQ2fog5YeCXCPIp+fF3n4OjiTx0P99A/tjiYxamQoVPOLky2zN6gfA8Om2SxqlNHFVi7P1unokhpN4eue7GUISyLSlrm6bjb3vxpEYSRoh+nr2QZXLRI8YdTvMVPelTCkqX4s6LF22+JwpGtXqh6+CrewCkvRr9J9O34VdOlw33DJgurWRi3AO8vNR7RQkyIUQ6wD8HwC/AeA2KWWXH4MqF0G21RV7+7k9nQUwhX3Up90BoW6f1jVx/ZBSuQACKQ19NDluyvGhvFGUoE8hTdkF7YpgqKyJ+2MJTJ82BV19g8Zn9THYuSIC9ilmVf/KBt7VN2gsHno0qp56QJ8ftfM43D+Ibz5wi21Gw3zPKNyErhe3STusuVby6YOUn0I18rcB/B6AZ30YS9mpZlud0iZTOVKko0ZpJ2Ta581AezproHUOrXZkVSh546pWbLrvRsMbRbnXqeo4gDlJlzUplxpzYvgSus9exFhy3PBDV4uGGose7al7mOgpZjfdd6PpoFXZwFWOFv2gU9+tZAq+1CLS2ZvA9q6BvDIaOglMt3by/9s151opTh+k2BQkyKWU7wCAEO55O0iw0FO5KhOGElDqMFAXeDpWIaOSVekC1qtWp7RVPdRd986wC4HXhVtDXQ0a638Nnb2nsHThTFNuFzMp4XpHcyrkXjdd6EWiG+pqMtzfrOacbGlfU4uIgO7Nou8MvBw8OgnMYmjE1lwrQdO6aZf3iJSy4H8AXgUQzXLNBgBdALoWLFggSfnY8mqvXPiVHXLhV3bILa/2mt5LDF+SW17tlYnhS57asrtetW9t2+u4cvmcl/Far9H7ydan22ellLL3/YvyD//xZ/KvdnRnnbOnXj4uF35lh3zq5eOe788ruX5vYSHfv6VKBUCXtJGvWTVyIcQuAB+xeetrUsof57BgbAWwFQCi0WhumZiIrygzipOdN5fts931qfYnMKqVTfM6Lv2nHXbZEe3Gaxft6daPU5/W9q2f3dV9Dp29CXT2JtBYn23u3OuCFkKlHkQGbYcQVLIKcinl6lIMhJQOuzzYuWK35dVfU7ZwADYl0ZzHle9BoLJlqzB2u6IYuuujXbGHfMuc6eYZN+xSxuoFMaxFMHKhEF/+IEO7vDfoflilFPpQ2wlUa9pVABkl0XIdj/V1O4E1OJLEhue60vU+u/Gdz9+WcZ3uWZOrj7fbNV4Cg9z8860FMfIVWsWI2CXhoVD3w98F8AyACICfCCGOSCl/05eRkaKgNECVbRDI76F2M0/o3ivWw0wnnISMneC0E4ax+AiaI3V4dE0bgExXSadEYNnuKZ9rrGO2+tpbIzq9avSFQjNF5SJS9vPSEo1GZVdXqF3OQ8ekz/RkQMsdzY145jO3BGKb7VUjd/qs8sJZ2zEnI1jpniURQ4BmMwn5MRd2GrlKiLXpvhsdF04vFX9IdSOEOCyljFpfp2mlSpj0mW7FipZZ6Ow9j2hTQ2AERSG20FQq3FTVHpWVEDAn03Lz6Z4sbjHuas/PNzWsW2pgnVzSFRCiQ0EeAvzQGPVttaoaH6QtdqG5QnRf7fZ5Z9LmCmQIUDeTUDZ7fiE2Zi8LlX4PThV/wnhgSYoPBXkI8OOQyslTIyjkmytEod+frp0/eX9H1uRUXu35xS6A4KXiDw8siR0U5CFAF2aVqpFZBXb2TIzubXnxUvGCPg67dLalxm2eKunvgeTGVeUeAMmO0tT0kPDtXQOeP69yUk8mfAoe+j0CyOs+9baevL/DCNn3il2f+mvrovNNGRzLQT7zFIbvnxQGNfKQkY8LWRi344W6yllNKF4LQVv7tLpUejm0LCX5uEOSyoPuh1UAt98wkoG5uf+FiVy+U37/lYOT+yFNK1WAdTseBEq93V8Xne9oarEbi/5aEE0TuZiegvj9E3+hIK8giilw/G671LZ+N2GWzTZeDDt0ofPptjCR6oM28gqimLZQv9tWGRjdyqIVcwy6uSGbbdz6mh9jK/RemEyK6FCQB4xC7JnFzKXhd9t6NKa19mUpxmAVpG6+5V6+j1zHxrwnxFfskpQX+9/SpUuLlXc99JQykX6pixFY+/O7/1za83ptsYpdEJIPyLewBCktpdTUSu2W5iWToZ/tu+G172px9yThhoI8YJTS9lnq7X2x+ytG+/l8HzSbkFJDP3ISWOj/TIgZ+pGTgim1P3UhYfqEVBM0rRDP2Nl+i6k100RBiDeokRNb7LRvuyCUYmjNqm8AvkckFmtXEcToT1I9UCMntli1byfNuxhac5gCm4rdLiFeoCAntlgFtJOgKoaXTZgCm4rdLiFeoNdKFVGIPZseJISUH3qtkIKLNTCDHiHBhKaVKoLbf0IqE2rkVYSbVh1Ur4ugjouQIFGQIBdCPCGEOC6EOCqE+FchxAy/BkZKS1CDb/IdVykWAC4yJCgUalrZCWCTlHJcCPG3ADYB+ErhwyKlJqhml3zHVQp3QLockqBQkCCXUr6s/XoQwKcLGw4pF0EtVJDvuEqxMAV18SPVh2/uh0KI/wfgB1LK7zq8vwHABgBYsGDB0v7+fl/6JYSQasHJ/TCrRi6E2AXgIzZvfU1K+eP0NV8DMA7ge07tSCm3AtgKpPzIPY6bEEJIFrIKcinlarf3hRCfA7AGwCpZjugiQgipcgr1WvkkgD8DsFZKOerPkAjxDj1HCCncj/zvAVwDYKcQ4ogQYosPYyIBJ0jCM6huk4SUkkK9Vlr8GggJD0Fyu7N6jjAnDKlGGKJPciZIbndW98QgLTKElAoKcpIzQfU5B4K1yBBSKphrhRQdv2zqQbLNExIkKMhJ0fHrQNJLOzz8JNUITSuk6Phl7vDSDk0rpBphhSBCCAkJrBBECCEVCgU5IYSEHApyQggJORTkhBAScijICSEk5FCQE0JIyKEgJ8QjjCwlQYWCnBCPMGqUBBVGdhLiEUaNkqBCQU6IR4Kc9ZFUNzStEEJIyKEgr1J4cEdI5UBBXqXw4I6QyoE28iqFB3eEVA4U5FUKD+4IqRxoWiGEkJBDQU4IISGHgpwQQkJOQYJcCPGXQoijQogjQoiXhRBz/BoYIYQQbxSqkT8hpWyXUnYA2AHgz30YEyGEkBwoSJBLKT/Ufq0DUPpKzoQQUuUUbCMXQvyVEGIAwB/CRSMXQmwQQnQJIbri8Xih3ZKAwAhRQspPVkEuhNglhHjb5t+nAEBK+TUp5XwA3wPwJ07tSCm3SimjUspoJBLx7w5IWWGEKCHlJ2tAkJRytce2vgfgpwC+XtCISKhghCgh5adQr5VW7ddPAThe2HBI2FARog11NeUeCiFVS6Eh+n8jhFgC4AqAfgAPFj4kQgghuVCQIJdS/r5fAyGEEJIfjOwkhJCQQ0FOCCEhh4KcEEJCDgU5IYSEHApyQggJOULK0qdHEULEkXJX9ItZAM772F6lwfnJDufIHc6PO6Wan4VSyozQ+LIIcr8RQnRJKaPlHkdQ4fxkh3PkDufHnXLPD00rhBAScijICSEk5FSKIN9a7gEEHM5PdjhH7nB+3Cnr/FSEjZwQQqqZStHICSGkaqEgJ4SQkFMxglwI8YQQ4rgQ4qgQ4l+FEDPKPaYgIYRYJ4Q4JoS4IoSgG1kaIcQnhRA9QoheIcT/Kvd4goYQ4ttCiPeFEG+XeyxBRAgxXwixRwjRnX6+NpZjHBUjyAHsBHCTlLIdwLsANpV5PEHjbQC/B2BvuQcSFIQQUwD8A4D7ALQBeEAI0VbeUQWOfwbwyXIPIsCMA3hEStkGYBmA/1mOv6GKEeRSypellOPpXw8CmFfO8QQNKeU7Usqeco8jYNwGoFdKeVJKmQTwfaQqXZE0Usq9AAbLPY6gIqU8K6V8I/3/iwDeATC31OOoGEFu4b8BeKncgyCBZy4AvWr0aZThISSVgRCiCcDHABwqdd+FlnorKUKIXQA+YvPW16SUP05f8zWktjvfK+XYgoCX+SGE+I8Qoh7AvwD4kpTyw1L3HypBLqVc7fa+EOJzANYAWCWr0EE+2/yQDM4AmK/9Pi/9GiGeEUJMQ0qIf09K+aNyjKFiTCtCiE8C+DMAa6WUo+UeDwkFrwNoFUIsEkLUAPgDAC+WeUwkRAghBIBvAXhHSvlUucZRMYIcwN8DuAbATiHEESHElnIPKEgIIX5XCHEawO0AfiKE+Pdyj6ncpA/H/wTAvyN1SPWClPJYeUcVLIQQzwP4GYAlQojTQoj/Xu4xBYw7APxXACvTcueIEOK3Sj0IhugTQkjIqSSNnBBCqhIKckIICTkU5IQQEnIoyAkhJORQkBNCSMihICeEkJBDQU4IISHn/wPt3DJ1FSR5EAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2df3hc1XnnvwfZg/XD2Bp5ELYkW9YP7MjgGDyA8c9gmy00PCZNI9ok3TjpdgV92tRl2W3WDQ2QkNI+KVCX7S64DazdZJugpmlYJ2yxjcE/sAE5NRQLy5Js2bIhsjwjG0sjGEs++8fMuTpz5/6ce2fuvZr38zx6JM3cOec99859z3vf877vYZxzEARBEMHlKq8FIAiCIJxBipwgCCLgkCInCIIIOKTICYIgAg4pcoIgiIAzxYtOZ82axevr673omiAIIrAcPnz4POc8on7dE0VeX1+Pjo4OL7omCIIILIyxU1qvk2uFIAgi4JAiJwiCCDikyAmCIAIOKXKCIIiAQ4qcIAgi4JAiJwiCCDikyAmCIAIOKXKCyBPxkSSee70X8ZGk16IQkxxS5ASRJ9o7+vHEy8fQ3tHvtSjEJMeTzE6CKAZao3UZvwkiX5AiJ4g8ES4P4f41jV6LQRQB5FohCIIIOKTICYIgAg4pcoIgiIBDipwgCCLgkCInCIIIOKTICYIgAg4pcp9AWYAEQeQKKXKfQFmA7kATIlGMUEKQT6AsQHcQEyIASsYhigbHipwxNg3AXgBXp9v7J875I07bLTa8zgKMjyTR3tGP1mgdwuUhz+RwCk2IRDHihkX+CYC1nPNhxthUAPsZYy9zzg+50DZRICaLJev1hEgQXuBYkXPOOYDh9L9T0z/cabtEYSFLliCCiyuLnYyxEsbYEQDnAOzknL/pRrtE4RCWbJDdKgRRrLiiyDnn45zzJQBqAdzKGLtBfQxjrI0x1sEY6xgcHHSjW4IgCAIuhx9yzi8A2APgLo33tnLOo5zzaCQScbNbgiCIosaxImeMRRhjM9N/lwK4E8Axp+0SBEEQ1nAjamU2gG2MsRKkJoYXOec7XGiXIAiCsIAbUSvvArjJBVkIgiCIHKAUfYIgiIBDipwgCCLgkCInCIIIOKTICYIgAg4pcoIgiIBDipwgCCLgkCInCIIIOKTICYIgAg4pcoIgiIBDipwgCCLgkCInCIIIOKTICYIgAg4pcoIgiIBDipwgCCLgkCInCIIIOKTICYIgAg4pciKQxEeSeO71XsRHkl6LQuQBur72IEVO+AqrN3B7Rz+eePkY2jv6CyQZUUjo+trDjT07CcI1xA0MAK3ROrR39KM1WodweSjjuNZoXcZvYnJB19cepMgJXyHfwLJSv39NY8Zx4fJQ1mvE5IGurz1IkRO+Qr6BySojCGs49pEzxuoYY3sYY52MsaOMsU1uCEa4RyEWjvLRh1DqarcKQRCZuLHYOQbgIc55C4BlAP6AMdbiQruESxRi4YgWpwjCOxy7VjjnHwL4MP33JcbY+wBqAHQ6bZtwh0K4KMgNkk18JKm7WEsQbuKqj5wxVg/gJgBvarzXBqANAObOnetmt4QJhVg4osWpbIwWawnCTVxT5IyxCgA/AfDHnPOP1O9zzrcC2AoA0WiUu9UvQfgVekohCoUripwxNhUpJf5Dzvk/u9EmQQQdekohCoUbUSsMwPcBvM85f8q5SARBEIQd3IhaWQHgPwJYyxg7kv75dRfaJQjCJlSjpDhxI2plPwDmgiwEQTjEaokDYnJBmZ0EMYmwWuKAmFyQIieKkska400lDooTKmNL5ETQfbHFkIlKJQ6KB7LIiZwI+mM7WauFY7I+/fgJssiJnGiN1mHz3QtdUYSFtO5FXwDIWi0QxfD04zVkkRM54VayS3wkiYdePII9XYMA8m/du/kkUQyWphtjpKef/EMWOZEX7GzZtqdrEHcsiBTkRl/fUo07FkSwvqXacVtuW5p+XHdwY4zkq88/ZJETecHM8hWWnlCohbJqd3UOYE/XIJY1DKBxTYWjtswsTbvWrB/XHciaDgakyIm8YKYAhNI6dCKGJ+9bUjBrzU3FZOZesquYtWTz2n1D9WKCAblWiLxg9jjdGq3DHQsi2NM1mPXYbtfFYOf4Qj7mt0brsGldExLJ8ZxlE5PBQy8e8ZXLRQs/uoaKBVLkRYSfbrRweQhP3rdEM/JFzy+rJ79foyLC5SGUhaZgy+7unGUzmvCckI/vgl+vQzFArpUiolA+WNkdIPrVcg0ICzQ+ksTTO48D4Ni4fL6u+0NPfnHc+pZqPPd6ry03RO/gMB7f0YmH72lBYyTbZ+7UteHUlSMmPPl8ukE+vgvkT/cOUuRFRKFuNFlJADBVGO0d/diyuxsAUBaagvvXNGoeqye/mBCee73XtnJ6fEdnOvSxEy987VbDsdy/ptFU8atxw8ecDz91Pr4L5E/3DlLkRUShbrT1LdU4dCKG9S3VqCxLWbFGCqM1WodEchwAR2u0TtcKli14LctbTzkZWdUP39MCoDP9G1mfSyTHsWldk9KmUPyn4x1of2B5YEPqSOlOLshHLuEnH3KQESF+uzoHLC0uhstDePDO6/HgnQsQLg8Z+lpFApHW++q+xPXc9kafbnuNkQq88LVb0RipyLr+4kmhLDRFaTNliZejd3DE0Ifvl++SX+TwimIZP1nkEn6M4w0iTh/btT4vXBrN107PSiDSs7jF9dy0rslSOQH19b+lPoz6qjKcHUogPpJEuDyExkgF2h9YrumztutSEuQzxLDYv9PFMn5S5BK0WOMOTh/btT4vXBqJ5BjuWBDBw/e0KErPbBHUqoJUX/9nXu1GXyyBvthp1FSWKW2Hy0NZmzZouWHktrQQCjyRHMeW3d1IJMdRFioxXSRWf97omGL/ThfL+EmRS5Df0F3ctDSFL7u5ejq27j2BxbVnURaagtZoneVEGjN51Ar64XtacHn8KFpmT9e1voXyFcp4890LlbaN/PlyG+KJIZEcs71IbHZMsX+ni2X8pMiLjEJmCrr5WCt82fGRJEqnluDwqTj298SUttXta/VtRR71MT/4vds0jxOKXShfPfeNUZ/qJ4b4SFKZnNTHGMkQFGvT6yzVyQwpcp9QqC95IX2G+QpxKwuVYH9PzLDQllbfVuSxK/OGJTWK8tW6bkbtGVmLWu4bK5+3+j3yQqkWi7/aEzjnBf9ZunQpJzJ59rUePu8bO/izr/WYHhsb/oQ/+1oPjw1/YrsfJ5/1Ai158zWGnnOX+Feff5P3nLuU0YdWf3aulyz3U6908adeOaYpu7pN8b+QycqYrcqVi/xOceO6Be376zYAOriGTnXFImeMPQ/gHgDnOOc3uNFmsWHHEnRi2RTSZ+iG1ac11nyN4Vv/8h4O9MaQHHsPq6+PZPmr5cVIOVZeC62xayU+ycepvwOt0TocOhFTEpbEYm+uTwC5HOcmblw3suq1ccu18r8B/A8A211qr+iw8yUPim9UvSCYi0K3O1Ynk8eimhk40BvDopoZmv2eHRrFlt2nEBtOoqoiZFgOV0vhaCU+qTfVkL8Dcnr++pZqLGsYQGwkiS27U+f0wTuvz+rX6vfIiuvGjwTlu19oXFHknPO9jLF6N9oizLF6s+bLD2q1XfWCIODeE4RZ7PihEzE8fE8LdnUOWB7/A2saUTq1BADPkvX+NY34nb8/BAB4pfNX+P5Xb8kYo1ouuc66/PrG5fWKnInkuOVNNSrLUufh6Z1d6Ve46XjMCKJ1WyxRKHYp2GInY6wNQBsAzJ07t1DdFjW53KiyItJTglbblVPq1dEYTjGKHVe7I8zklOUFgC27ewCwLIv3sXtvQNv2DvQOjuClIx+gLFSivKeOCVf3qZUs1LZqflZMvNk4Ny6f79q5dGrdUhSKfyiYIuecbwWwFQCi0ahzc4IwJZcbVbZo9ZSgnXblicHuTW+kKIxkWFw7A4trZ2LDkjlY1jCgK6dWlcbR5BgAoKMvjt7B4YzJTM7qFE8Z6jhyOQzRyP8NQLHIhXtGa7zqz6ktUivK1Kx2Ta4E0aKfrFD44SQmlxtVKAzhk7UbNqfGysRg9lmtz+jJkFpQ7MGmdc2mbhVZNpFo1La6ASsaq3CgN4bNP3kXb/UNYe/xQTzzpZsRLg9lPWVoxZGL/tTVGNWumlQbJbilPoyvvfAWmq+djq37TqT96IAo6+t0F6J8KVzyV/sHUuQu4OdHTLuyyQrS6Z6WgLWJweyzuXxmwmLWj/KQ3TCJtCUOzhGtD+NAbwyMMQDAgd4YHnrxSMaWdHpuI/lcy5EtWtdBtPG1F97Cnq5BXB6/omR4ptw7E9EtTs5RvhSu0YTu53tiMuJW+OE/AvgMgFmMsTMAHuGcf9+NtoPAtjdOYsvuHiSSY3jwzgVei5OB14+/TiaGXJ4osi3mcUOrXkSFxIaTePPkEEpDU7BxeT3KQiVY31KNl458gIO957GnaxDPvtaDqoqrNZUxkG2Byxs9A8jao1Qou6+vbQYApcZ5qlIfg4hucXqOvFgg9Pp7V2y4FbXyRTfaCS5M9ds/FOrx1w8WmFoG2X2hjh5RW9AAUFURyvgsAGXB862+IXR+eAn7e04CgGbonlYcuPxbWP/icyL0cPPdCzM2tRBlfa2M0e77ubSZC+R2KSzkWnEBYcH58UtrZo25dRObWWBuKBizNqwkD217oy+j0qCWD1vdj7i+t9SHMbWEKQu3Zn2pY7XlLdvaO/othx6ajdHO+7m0mQsUJlhYSJG7QJC/tG7cxHolXLX6Ea4F8ZqRktarMKgna2u0DrHhT7Cv+zzWt1TrbMXGld96VqNWIpPYSk64SqxanOrzKycHid92JlCzfuX34yNJbHujD2LRlErdTl5KHn300YJ3unXr1kfb2toK3i+RUrrbD/ahIVKB0lAJGiIViuVYKsVF22H7wT781SvHsXbhtVjVHMnqAwAaIhU4+sFF7O0+j2lTS9A9cAlPvHwM4fIQovVhbD/Yp/zfEKnA9oN9uKU+jHOXPsY106Zgy+4eLGsIY+3CaxVZ1f2Uhkrw/IGT2Nt9Hv3xBFZfH8mSY8F11yBcHsKXbpun9K0etzgnl8ev4K9eOa4cJ58rvc+qEZ+5pT6M//ZP7+LYhx9hUc2MrM9rnTMtSkMluv2qJ0NxXd48GVf6Ux+//WAfFs2ZgVXNkZyvP1E4HnvssQ8fffTRrerXySIvMtQWYi5PE2qFkUo9H0MiOa68JyzalAXMsHF5PZbOq0yXns22huXf4vN3LIhgT9cgFtfOzArtk8ciW/l1laWoryrD19c2Z70vhw8aoReRkoubSo5M2d9zHvt7zqOq4mpLZXeN2tVC3Ya6JIDZ8URwIUVeZOTyGK1WJFqTQVloCp54+ZgS7XHoRAxDiSS2HzwFACgLlWDj8vkQ0RhDicw9FGUlqQ5ZFFmmalnk8MGHXjyCxbUzsf3QaQDA231xtEbrsK87HXHyei+qJGvabIxGiG3nRJSJwEgxik0qGmaVKROe3I96MtSasLTaldFKHtJbNNU6XuCHhWvCHqTIi4xcLHAtSw/IVAByzLQIu1vRWAUAWNlUpRz77pkL2NM1iHfPXMSerkHs6x5Ey+wZKA1dlVb0mb7zxjUVGWF9QObOOU/et0SJ/mi+tgI3z52JX138GL3nhrHtjT60zJ6O/T3ncfTsRRzondiIwmyMckEr2aIHJradAzozok2MJsnGSAV+8Hu3KWMpC5VkLYzKk6HelnVA7pma6s8ZJVWRpR4sSJEHmEJZTrKFLLYtU9/gcsy0OP6W+jBCr3YrtUTEYmG4fCo23l4PANjTNajs9ANAUfDAhBKRJ4nKssxQPzkWPJEcxy9PXwAAvHj4DADgvmgt6qvKUDNzGtpWNWhavHJ7cljinq5BNEbKlZBBoeCbq6cjOXYlvf3cBLJi1Ls2RkpZvVCpFUr53Ou9GQlDdhRtrpY94X+u8loAInfEjdne0Z/XfoYSSRw6EcOP39bvrzVal+HHvn9NI97ui2NP1yB2dQ6kI1vGUF9VhvjIZWw72Icn71uCTeua0baqAZvWNWH08hXs6RrEyqZZGUpETBK7OgeyEnCEUk4dz3FftBa1M0uxuOYaAMBbJ+PoiyXw4uGz6D53CVt2d2vKL9oNl4fQOziMfd3n0bZqPrZ+JZqxhVt7Rz+27j2B0JSrlElFC/naCAUsZBX9qI+T39O6thOKmGluKwcgoy+ja2SEWkYjjPojCgdZ5AEmH5aTVuy2qPiXHLuSpQjk44XV+PTO4+niUwyb1jVjfUu14qa4bX4YNTNLFStd9uGKEq2pjVCyxyk/EaitS1Fj5Y4FEZy5MIrfXFqDzy6eg1vqw3hq53G0zJ6O37p1rqUyAY/v6MT+nvOYWsLQGKnIyEhN+d0HsadrENveOKmbyau1eCtk1TtOPqda4ZxWQhZzqU/jBHLD+ANS5AFErTzdRF1uoL2jH72DI2iMlOPbn7shKzZbW6F2K+9vvnuhYlGHy6fizZNxbL57ISrLQmnFnYpoSSXezFdcK8KVAUwoIOFfjg0ncfSDi2hb3ZCh3BLJcYwmx7G4dkZG3LS8gbKslHsHh/Gtf3kPNTNLcSo+gk/XVuKBzzTi62ubcTqeUFLnZcLlISydF8b+nhhGk1fw9M7jEHHa4nyos0O1JiKtFH8AGb75zXcvNPWBa0UQyX3mG3HeE8kxTZcVURhIkeeRfPmw7VhB9mXILDegtgJFe7fUh/HMq934+trmDCtd3NhDI5/gxPmE4tcW0SUrm6qQSI4pE4ZAJN7I2Y+phJaTABg2LJmjWKmHTw3hQG8MoSlXZYxJLKSqFaAej+/oVBZAAeDNk0Ooqkh9rndwBG/3xXHzvMqsz4lMTzlBafTyFVSVh7LCHYHsiQgwrlRoJ+Mzl3BSN7+XqUXakvQirXGBLy8olggcSgjKI3KSizoZwwl2knjsyrDguulKwoxIspETUER7O9//Fd7/8BLOXfoY3/ncjcr7paES3N5YheMDw/g/b51GzcxSrGqOYPX1EYTLQ4hMn5ZO7qnCsoYwljVUYTS9eDdt6lVYu7Ba6U9OaOmPJ/Cjt/uxduG1+E+rGtAfT2RsyLD9YB/+4dBphMun4vfXNGH2zFJlTHrJNjfWzkDvuWHc3lCFimkl+OyNc7BxeT0WzZmheX7lBJpFc2bgnf4hfHBhFB99PAbOOT68OIrZM6Zhf09M83xrXTe1bJXlIWVsNdIY9Mglocvt76WeDFaTnPJJvu5Br6CEIA/I12OuHV+nXRmM2ha+W1GvO1w+VXE/ZFvPY2hb3ZDxyC0XsZJ3IEqlkQOHTw0px4q+2lbNR2loSsYmEeHyUEbYnxjfi2k30DOvdme8r/cEU1kWwurrIxlPG8++1ovODy/iv6TdSrIlJyc6HToRw5sn47hvaS3mXhhFX2wEZy98jMU1M9AYKcctGkpD69yqZZOjf6xUi8zF7+3299LPYYzFEoFDijyP+KEGi5syCP/3pnXNYAzY3xPD68fP4eZ5lcpiIzDh4hCZmfIjt5abYePyeuUzwjcu+tp890LdMrjqx+atX4kqiToyejezln9/674TAIAPL76D3sER5T3x+URyTFHiAHAqPoJlDbMUF81QIon+odGsycRqOKIbisfMnVCo76UflKgf7sFCQIq8SMnFd6i+MVPx3xO+9EQ6UuWmupk4HU9g4+31WNZQpRkXrfa9P3nfEmx7o0+x4K0oAbUiboxU4IWv3aqExJklvmgpz9hwUrHIRXaoQCTtCCUOAJ+urYQoxLWisQr/eVUDvvPzzqyFUr2a9WrZcikDYHZerLZhpdqkXlarFur498nup/YSUuRFSi6PvbKSUZfuTYUSLkgp4WffQO/gCLYd7FOsUvVCn5YCk8vKilR+LfR2qhcIpRkbTio1xsWY1ZtKq2X4089+SlOByX2momPGlE0oACg1WUSUT/ZCaeYisuyKElE7VrBy3cwmQbkNIbMcJikWa7X60stqdSqzFsWyUOkGpMiLFKePvUZ+0d7BEdRXlaH52gpVwo52CJ5aJjkaBEBWrLaeIppoL6Us3zkzhDdPDinbvan3DtX+rLbikV/Tql+iVZ5WRj3xPft6L7buTblx1Cn5Aq0ytFaum5lVrxfj3hqty9r8Qt1Xym2V7b4ywkhmI2XtBx97UKColQCQj9V/o3KodmWRXxMRH42RCvzP13pxfOCSErESrQ8rN+fxgUu4sXYG2jv6M8rQRuvDWHDddBz94COcjiewrKEKt6drtgjkKAnRnhyVICJvrpkWwuHTQ1jWUIXljbPQcSqOP1rbjE/Nvibrs6J0rjwGOQpD9Ck2ldC7FqI0cHtHPyrTGZris9H6MEYvj2P7wT4cOnEeZy98jHnhMnz7czdonsv2jv6MMrTiNdn1YXQt9K6tfO3VpXnFtRL/q78j4fIQPndTjS0L2ei7ZhRV4kaJ5ckGRa0EGLctEyePrFqlYbU2YgCQtYAJZFp9p+MdWQuKgqXzZmLpvErFdSG7NmTXiJa1J/tmhWvl939wGL2DI/hfr/fix/ffnvEZrexLdZKO6PuRn72H/T0xJJLjupUFhWtnX3eqjozWuWpb1YCy0JSMEEr5/L7Y0Y/vfeHT2LSuGaIMrZHrQ7xvtw6LmY/e6uYUuWJkrRfLQqUbFJVF7oe41lxw2zKxElurd64aIhU4PnApnamZueGCvBGDHDsuy10aKsHq6yM4PnAJvzx9AXcsiODBOxdk9CFvVLFozgxsP9iHnUcH8Lev9WLPsXP4+b//KsNaVFt78ZEknn29B+/0X1Q2kPinw/04e+Fj1FZOw7pPVWfEgwslXTOzVPMci/PVH09gb/d5AMCna2ei88OPNL9Lh07E8ebJOO5aNBvXlE7RPFcbl9fji7fOzVKMDZEK7Hp/AL2DIzgzlEDTtRXKGOTNOUQZg2UNVfjSbfMUpb6soSpj8w0z1NdZ/b/Z5hS5EtRNLbzWIWSRI7g+N7ctk1wiQmRZ5OxLWT6tjRhao3VKbPZj96ZS/OU2hKtCfjrQspTrq8oAAP1Do7pZj8Jylq1S4X/+888vVqIt5LEBsLR4mEiOYfTyFTRfW4HS0BQAPOtzov8NS+YoTyapuuudysKsfC17B4fxyM+OomX2dDzwmSblvP/ZZ1vwyEtHcenjMTzx8jH869FfoSw0BY/du0gpD5DaCPo8VjbNAsCxYUkNYiNJdPTF8e3P3WDJcpbLAYhxqK38VCx/A0pDV2lGH+VKUO9Fv8rtiiJnjN0FYAuAEgB/zzn/CzfadRs/xLXmCzs3mJWJQX2utMqqGvUvHsk7+uJKjHXb9g60P7A8IyRQK21dbl/0ry5+peVmETfZpnXN2LSuCQBTPi9CEwGgMpo6P+tbqvHSkQ8M9xoV8pSFpmDL7mNKXLt60gL0F0nlBB/ZVdHRlyo1IHYNEhPQyqYqnIonlHZFad5HfnYUf/PFm5SEqpSbJ7XrUFloCroHLuFAbwyP77AWUSJkW9k0SzPsU8Ty37EgoriGrJQZsEJQ70W/yu1YkTPGSgD8LYA7AZwB8DZj7CXOeafTtt0mnz43r0Ol3LYU5HOlZbmZ9S8Xz7ptfhgDH32M3sGRDH85kF10SbSlFQMuil8JZSJ87cI3L4cjymGDWoWqWqN1usWptLByA2sdo35NPi9tqxvAGFN2DRpNXgEAtMyeAc6BA70x3FpfibErHL88fQEts6dnnA+xdd6KxlSs/i31Yd1iX+JcaMXyiwlEJG5prWeI6+aWIguq/9uvcrthkd8KoIdzfgIAGGM/AnAvAN8p8nzi9SNXPi0FK4WctJJrRLw1wAAGlE69Kuvzcvx4WSj1dVTvw6meIG+pD6MxUo6Nt9djce1MJdMyNpJElUEIm7Ay17dUK/HQ6jFZ3X1HLGjuPT6IZ750s27ikfo1cV7kxUMxMbWtbsAdCyL4rVvrUFnWmOG+kv8WbFw+H2WhKYp7KpEcy4hht7JFn97ThWBx7Qwsrp2Z5UbzGq8NJ7/hhiKvASBX6j8D4Db1QYyxNgBtADB37lwXuvUXXj9yuXGDyTcHMKE85LHp3TRa0Q8P3nl9xqO4nuWrPnfCCtz2Rp8S+QJMTJDPvNqtJBwta6hSMi21tnPT8reLmiyyy0Cw7Y0+bNndjX3d5/E3X7wpKyFIVH2sC6d89gd6Y1lPGUaI86I1/kRyTHHDCOtXXAOt9tXuKTERiCcTLX+3mRtJRkxWKxqrlOghu/ihAmgxULDFTs75VgBbASAajWqn7AUYv1gqMnZvIr1FQCeTk1golP3VatTnbmLrtjFNq1lOSqksC01Y/oxh0ZxrMrZzk9te31JtqMTjI0kcPpWaFPb3nM9Q0OLcNEbK0Ts4gpVNVRmhgU7Qs4zFpCKeNPSuY2u0DrGRJF45+iv0xRJY1jCAymgIieRY1sYeWpOpllJMnYuUb95sstIzALSeAtzCa8PJb7ihyM8CkM9mbfo1wmPs3kR6Pt4JK3UQf/PFm21ZViJ13wpauw0JxSb3KS9cAsiw/Fc2zcL+nvPK6zK7Ogd0lTiQOl/7e2JY2VSFpfPCGVmo4pwsqJ6OR//vUTTMKseGJXOwq3MgS/ZcLU85ySnVX8reUT9paG2i3D1wCX2xBBoj5dJCZU/Gxh5arjH1bkQTkT/jSlTM0nkzDRWmURSQnsJ1er78aDh5iRuK/G0AzYyx+Ugp8N8G8CUX2iUcYhZ5oka2DDOPSymU/T3mboRcblDxmdhwElv3nVAKS8nymBVdEmOMDX+SVuTZD31mLiL1+/Ki6pP3LcH9axrx9M7j6Isl0Bc7jf6hUcXtAyDLF5+LkpKVouwDf+nIWeVJQ2uCfvieFiSS/w6AYyihXXRM/C2fS7H4Kix1MeZN65oy9mA1wqgvPYVLrhF3cazIOedjjLE/BPCvSIUfPs85P+pYMsIx6pvI7OaRrTERWXH/mkZsWFKDw6eG0DJ7hq5lphXDbfUGFXKtbBKp+BOFpbTkMeKuG2aj+9wwNiypyZJN7WvWsmxlJSxcMXu6BvH7PzgMgGM0OQ4AuG1+JR6+pwXLGgaywhitKCmrZW2BVN10UStGzpyVj2mMVKAsVII9XYNK+KHct/j76Z3HsYuFBd8AABeqSURBVGV3t5KZqrVILX5bnYTU37Ncn/6I3HHFR845/wWAX7jR1mTEixV2rT7Nbp6JOOymjO3bdnUOYH9PDKuaI7ryyzHcVnZql2UUi3NyXLjc5orGlD9afvRXn0txrKiBLm/MoFdCVi/uW3YTiP1K5dK1QKp8rZBVbdWqz7NW6VejhCvxv7COE+nJQ0wU6tBQcT7UBa20Yvs7+sQ4eFZ/Tr6ndj9LrhF3KarMTq/w4jFSq0+zm2d9SzUOnYhhw5KajFrTZhNAys+aWljLtSSrljtCjmMOTblKd1yybOtbqpWdhCZgqt/6O9WLcyD2GhWv/fitfnScStVfb4qU45XO1MKilfOjVfrVikUqR7MIf7fZQqXRzkjtHf040BvDHQsiymbR8vkwyxWQj1VfK3UdGAoJLCxFVWvFC1JW0BCWNYSVfTALgVyfRVTcM6sP0d7Rj384lNpnU66poVfPRF2lb+3Ca7GqOZLVrqh9cuhEHAuum55VUVB2R8j1POS6LKJeiVAerdHMWiJCRrkGi0C9DykwUc+lLFSCX1t0nfK6fA5WNUfQEKnAjnc+wMbl9fhk7AraD5/Bx2NXcPJ8amHx0Q03ZPWprmVzY+2MrD1G9SoCyudV1Fd5p/+CUlNFfbxRHR71e+J/sf4gI/Y81ap9o0arVo9WDR7CfajWikeoH7sLhawgrfqY7fgt1da0/FsrEUVd+8RK36Id4YuWlbiTx3jxBLGyaZZmdUb5t9Y4F1RPx3d+3onvfeHTAFIuEOEWEhtPyJa+OsrGCO0MWW1rXGtsRu8ZHWvHN651rcLl2TV4iMJBijzPeLmoo+fz1sOO31LEhwv/rdGiql4sufo4dd96bpSJHYA+QVXF1ZrKx2zDgi27e7BpXRNWNc/KUkhaLhvZN/30zi70Do7gqZ1dWDqvUsnwPNAbU37nOnEbLT7qYbSjUT581nrHkt/bO0iR5xkvv9y5RCBYQSgJgGHL7u4sK1utfPRiyc2UlP77KV93++EzGEpcBpD9pGG0LmHnvGiFQIr+9/fEsHReGJvvXojYSBIHemNYVDMDq6/XL2Vghp4VbRSCabZo6+T7Z2UfT6ufJfIHKfJJTL4mETNLX+5XRGx8fW2zspmxuKnN5NN7f+Pyeux49wMlokRLaRpNElbdM/K+mgBX3EOpdHUOeb/NuCr7Mj6SxNM7u2B3T051/0JGqxOTlfHbQcvVY3WCKMQiP00WKUiRBxCnX16nn7dj0YqIjdPxhO5uQHZlDZeHUrvn/OjfUB4qwV/v7EJl+dVKPRAR0phIjmPbGyc1d7axomRk3/7KplkZ4X/qJwy15axVE90uRusQauSxis+KY53sYC9H8ViRQybfbkU7kTaTHVLkAcQsbM8IK19+qxmgVhCxzbJFbqcvtcIVmzFcHh9H/9Ao+odG8e7ZjwCkFCYwUT1RjFGUZ5WxomTWt1RjX/cgLo9z7O85j1XNs0zPsRxPr66Jbhct/3ymiwdZSVhyBUmBHatYfT1Eer+Iy3fDl+4W7R3mVTmLBVLkAUS+we0+vlr58rvpX93VOaDEFd88r9J2X2qF+/iOTqWWys1zZ2BqSQmuu+ZqvHPmIhZUT8e/9Q+hbXUDwDmaq6drls4FzJVMfCSZ7iumFMiya4U6fdTXklGrrknb6gasbKrKyrzV+tvuxOnlYr0Z+VoDCiKkyAOIfIPbudGsJu4YtWnHLWNlQjCTX4y1d3AYD714BJ+/qQZH+i9gKHEZq5qvxYN3Xo8v/90h9MUS+LOfvYf+oVGsaKxSEl9yTU4RE159VVl6UbPSUkSI00xJvU2m5dfFRhyiDEGqvkymjHop83YnTj9HovhZtkJDijzg2Pkym8UkW2nTjrVuZZKxKr/sax9KXEZjJFV9MD6SxNiVVLp5ZPrV6B8axdgVjhWNVVkx4mqMFK2QWRTykrNCrZ4Dq7Vt5P7lDEmtvTQPnYhhce0MbNndg3fPXMST9y1Jbx2HDBn1sDpxEsGCMjuLCKMswHy0oZe9mAtKduRnW3Du0sf45ekLqCybin84eAr7e1LW9/2rG7G3exA950bw+Ztrs3aTF1b9jbUzEC4PZWUoqrMqo/VhLKpJHXv3jbPR3tGPhkgFFs2ZYekcNEQqMG1qCT4avYyOU0MZWa2AfoZkuDyEr66Yj5qZpWiNpjJzO/rimFpyFfZ2n8eyhiqlQJbIWFVnrurh5jXRw+ud5iczepmdV3khDOENwtrSSp557vVeZc/MXNoww6wPo/fjI0m8dOQsmqun4/+99yEi069GXWUp9nWfV/z9D9/Tgu/8vBPxkZS1vnF5fZacwqp/fEenZq0VYfU+9OIRRQ4x3l2dA3ji5WNo7+jPOAdGcofLU9vYbd13Elt2d6dj7ydojdZlhW+KtkWdFyHXlt09WDpvJjbfvRAbl9fjyfuWZJSZFeslVq6hnXOfC+I8qsdL5A9yrQQQt2Nnc13ctJNRaNaHUSSOHAYo0z80qvjB2zv6lbjyrV+Jap4XuTqgVumE1mj2ZsMC2SVhNb5bHK+3Q5JRso/YzCORHFfCKtXnVD5PenJY+a64He/tpwXSYokzJ0UeQPxy49nJKNRThOIzcilbER65r/s8ls6biQ1LahAbTuLl9z5E/9AoamZOQ/U10xCtD+OBtGVsJYKhsiyEZQ1VqCzLLjULGNcL0atdY8XnbLRDkn44aMrvf+hEapMMs1h4PTncWHC2i5/87F5UHvUCUuQBxC83np2MQrkPeecdsXAHpG60517vlaJFzmN/z3mUhaagqiKE/qFRZc/MLyytVWKmrY7BrLaLWTtaGa1qq1odbSIwelLZ0zWIFY1ViA0n8fTO49i4vB4bl8/Hu2cuYk/XIN48OZQRCy9vBC1vtqyFmwvOQcRPTwf5hBR5APHLjaclhxXZZBfG5XGe4aeeiBb5BFv3ncSKxiq0RuswlEji0ImYkliUSI7btrSc3tRGVr8o5CWKZqnl0tvcQrQpW/lAar9REZEyNJLEvu5BrG+pRmO6bLB6Ew1AO/HHL98VryiW8ZMiJ3Rx278ot/fkfUsUl4KcMSlbuHJlQ2G5LmuoUt4vC5VkbJBsJGNm3ZTcxm5cwCrVrn7RrInNLdRtizYP9p7HW31DGE2OKf09eOf1+J2/P4T9PTH87gtv46d/sEJpW2sTDb9ank5i6ie7f9sNSJH7CL99cbX8i05kVLcn/NGyMhbHtUYz99dU1/wQClC4aWQZ9fq2U/tEyJpIjisThry1m7rPjcvrlf00tc6L/L7W58PlIdzeOAtv9Q2hNJR5W7bMnoH9PTGciieURVjxObGdndn4vSYXX3Wx+LfdgBS5j5hQHmMoC03xXKFruSKc3Fx6ro2XjpxVlKxwMcSGk6iqmKgmqK75YdammvUt1Xj12AAAZuhTVrebSI5lJOgcOhFT9sS0Y/1aycaVlb3MA59pTMdj86z3/Db565GLW6tY/NuuwDnP+QdAK4CjAK4AiFr93NKlSzmRTWz4E/7saz38qVe6+Lxv7ODPvtbjtUhZCBl7zl3iz77Ww2PDnxgep/c+55w/+1oPn/eNHfypV7qUY5965Rif940d/Mt/dzDjHFhpzwjRl93zKo/3q8+/qSuTaF+vbafy67Vh1i+hj91r4sY1dAqADq6hU51a5O8B+DyA5xy2QyDTB6tlmfkBqy4Nq2FvqR2GuGJRblhSg3fPXMTX1zZj6bxBxIY/wZ///H2UhkqUeGq1f1qvPolRX3bHC0zEoQuL3k6ZWbWrxqoFbRaz7qbV6rV1X+j+cyk451dXjyNFzjl/HwAYs7aARFgjCCvtItElkRxHfCSpW6vELOytLFSi3BxloSlIJMeVRc2yUElGJEdZqERxvSSS43jwzusB6NcnUfcljs8VtXtHXnQ0U0BarhorBb3MJgsrVRzdLHKWTwrdv91J0M+unoL5yBljbQDaAGDu3LmF6paQcNPiSSnhKXji5WOai4dyAo1RTLUcfqe161AiOYbR5BWUpq3YVOQJIBJmAGQoVHUUh5vkmt0JTJyPbW+cxMom84JeWn3mMsG7XeQsnxS6f7vn09cGlpa/hWf6wXch5UJR/9wrHfMayEfue9z2pxr5DGPDn2T5lI3kED7onnOXTNv12k/JeeYYZNmtfEZeE8g3fjlfMn6UKSggVx8553x9nuYQosAUMiNU3sBCHestW9DiddltAejvauPEKjJ6IrHiZ5eRz+VEjPtERI1We0YJRVYRe6A+fE8LGiMVpsf70Yr02oUzGaHwwyKikDe18KEDDD9+ux9b955QCkBpuSSM0v3dwkiBWPGzy8jnUh3jrtVeIp3kYzUhSQ9RwRHoxAtfuzXrfSuTlZuLibm06bULZzLiSJEzxn4DwDMAIgB+zhg7wjn/NVckI3yHHWtQ9qGvaKxKv8p1lbd6krE64dhRJEYKRMvPrlXcS+tvoVxli1zdnpyCn+tmzEBmBUd5/MLyl/fvNNomzq0JPZc2/fiUEHScRq38FMBPXZKF8Dlm1qCMXO97w5Iaxb0gyHXxTo0dRWLUn/yeUMaZxb1mZkTQiMQtUdhKvQequr3ewWF09MWxqGaGbUtUnlAaIxXKuZcrJwrLf9O65qwa54JcLWGjcsXiKYSsa28h1wphGbU1aIRc77sxUuE4lVzP8tbyt7vlNmiNThT3Wlw7I0tBilBJK3uDvnTkLA70xhCtT21AbUdWuTa5HEIpr0M8fE8LljUMKJa5FrlOnOrJUr/0LuEVpMgJy8jWoBlu+0H1LG+rCUq5+HLV9cnlz6kTt8zbTPnGR5NXclCCXPU7hdo11bimIus8uOEXV19LeQIhS9wfkCIn8oKR9ZePBTKrmZWAPQvSqjvGDFFHRbbirSrBjcvnK7V39PrXc3W44RdXj9ON6Buvs0gnG6TICUPs3nB6C4R2tn3LBeMSs4WJlNA7V+pzkiJlXVtZQLa7aYaciJWPcRd6bYMwhxQ5YYiTehSAdjx4LsrFqhxmLph8ote3+nVRlqAsNEUKd8xcQLY7garj2s12QjKiENYyhSC6CylywhA36lEYuQTclqNQCkJL2en1rX5d/p1yhWQvINudQK2UybVKIaxlCkF0F5bK+iws0WiUd3R0FLxfgnALsai4+e6FeVFITlxaTq1o8l/7F8bYYc55VP36VV4IQxAAFH92fCTp6BgvaI3W6cZrq1GPwcqYhMVqVZEKK7q9o9/aAAyw2zfhPaTICVfIReFaUT5uKigz7ChcO8pOPYZ8jEmeWPw6+RH5g3zkhCvk4le14svNh89bL1NRHd/tlq/YyEfuFrLP2eo+psTkgRQ54Qq5KCcrC15asdJOfbdaClorycXqmMzkUo8z3wt9FBFSfJAiJ1zBy/A+wHnxLK0kF6tj8ltMNEWEFB+kyIm84mYEhJGl6bR4lvo1t6oqThYoksXf0GInoZCPRTKrC3t2IjkAZB1rJ4rETblludTZnJNpwbGQi86TlXx+J8giJxTy4SKwaq3a6VvrWLfdCUFIqikkfnvqCOITQj6/E6TICQUv63LY6bsQSsWq3Gbldf2i+JzgR6UZxIkyn98JyuwkihY3FJRRhqcfFWAu5DuLNRcmy7m1i15mJ1nkxKTB7s3thlXn1gKsn/Hj0wVF5mRCipywRBAsILuK0w0FZaRQ/KgAc4GUpv8hRU6YEpStvewqznwrKFKARKEIVPjhZAvpCgpOtvYq5DUzqn+SS+EqgggKjhQ5Y+x7jLFjjLF3GWM/ZYzNdEswLSiW1RtEjLbZBsNa+OWaFaJwlZ9xa+KiCdCfOHWt7ASwmXM+xhj7SwCbAXzDuVjaTBafY9Bw4iLwyzUrROEqP+PWwutkWcCdbLgWfsgY+w0AX+Ccf9nsWAo/LA6CsEBaLLh1Leiaekshwg9/F8CPDQRoA9AGAHPnznWxW8KvkPXmH9xaeKUFXH9i6iNnjO1ijL2n8XOvdMw3AYwB+KFeO5zzrZzzKOc8GolE3JGe8DVu1z8hCkfQfeFBl98uphY553y90fuMsa8CuAfAOu5FmijhW8h6Cy5Bf5oKuvx2ceRaYYzdBeBPAKzhnCfcEYkgCK8J+mJw0OW3i6PFTsZYD4CrAcTSLx3inD9g9jla7CQIgrBPXhY7OedNTj5P2IeiBgiCUBOozE6i+BJZiMJSbIuEkwWqtRIwis33RxSWYlsknCyQIg8YFAlC5BMyFIIJKXKCIBTIUAgm5CMnCgL5Xv0BXYfJCSlyoiDQIq0/ENfhoRePkDKfRJBrhSgI5Hv1B63ROhw6EcOerkG0d/STG2WSQJsvE0SRQbkIwYU2XyYIAgAtaE5GyEdOEAShImiLwqTICYIgVARtcZ5cKwRBECqCtjhPipwgCEJF0NYRyLVCEAQRcEiREwRBBBxS5ARBEAGHFDlBEETAIUVOEAQRcEiREwRBBBxS5ARBEAGHFDlBEL4laKnyXuFIkTPGvsMYe5cxdoQx9gpjbI5bghEEQQQtVd4rnGZ2fo9z/mcAwBj7IwDfAvCAY6kIgiAQvFR5r3CkyDnnH0n/lgMofHFzgiAmLUFLlfcKx7VWGGPfBfAVABcB3GFwXBuANgCYO3eu024JgiCINKY7BDHGdgG4TuOtb3LOfyYdtxnANM75I2ad0g5BBEEQ9sl5hyDO+XqLffwQwC8AmCpygiAIwj2cRq00S//eC+CYM3EIgsg3FNI3+XDqI/8LxtgCAFcAnAJFrBCE7xEhfQBoIXGS4DRq5TfdEoQgiMJAIX2TD9ohiCCKDArpm3xQij5BEETAIUVOEAQRcEiREwRBBBxS5ARBEAGHFDlBEETAIUVOEAQRcEiREwRBBBzToll56ZSxQaQyQXNlFoDzLonjNTQWf0Jj8R+TZRxA7mOZxzmPqF/0RJE7hTHWoVUBLIjQWPwJjcV/TJZxAO6PhVwrBEEQAYcUOUEQRMAJqiLf6rUALkJj8Sc0Fv8xWcYBuDyWQPrICYIgiAmCapETBEEQaUiREwRBBJzAKnLG2HcYY+8yxo4wxl5hjM3xWqZcYIx9jzF2LD2WnzLGZnotU64wxloZY0cZY1cYY4EME2OM3cUY62KM9TDG/rvX8uQKY+x5xtg5xth7XsviFMZYHWNsD2OsM/392uS1TLnCGJvGGHuLMfZOeiyPudJuUH3kjLFrOOcfpf/+IwAtnPPAbTXHGPsPAF7lnI8xxv4SADjn3/BYrJxgjH0KqW3/ngPwXznnHR6LZAvGWAmA4wDuBHAGwNsAvsg57/RUsBxgjK0GMAxgO+f8Bq/lcQJjbDaA2ZzzXzLGpgM4DOBzAb0uDEA553yYMTYVwH4Amzjnh5y0G1iLXCjxNOUAAjkjcc5f4ZyPpf89BKDWS3mcwDl/n3Pe5bUcDrgVQA/n/ATnPAngR0htKh44OOd7AcS9lsMNOOcfcs5/mf77EoD3AdR4K1Vu8BTD6X+npn8c667AKnIAYIx9lzHWD+DLAL7ltTwu8LsAXvZaiCKmBkC/9P8ZBFRhTFYYY/UAbgLwpreS5A5jrIQxdgTAOQA7OeeOx+JrRc4Y28UYe0/j514A4Jx/k3NeB+CHAP7QW2n1MRtH+phvAhhDaiy+xcpYCCIfMMYqAPwEwB+rnsgDBed8nHO+BKmn71sZY45dX77efJlzvt7ioT8E8AsAj+RRnJwxGwdj7KsA7gGwjvt80cLGNQkiZwHIW8vXpl8jPCbtT/4JgB9yzv/Za3ncgHN+gTG2B8BdABwtSvvaIjeCMdYs/XsvgGNeyeIExthdAP4EwAbOecJreYqctwE0M8bmM8ZCAH4bwEsey1T0pBcIvw/gfc75U17L4wTGWEREpjHGSpFaWHesu4IctfITAAuQipI4BeABznngrCfGWA+AqwHE0i8dCmL0DQAwxn4DwDMAIgAuADjCOf81b6WyB2Ps1wH8NYASAM9zzr/rsUg5wRj7RwCfQapc6gCARzjn3/dUqBxhjK0EsA/AvyN1vwPAn3LOf+GdVLnBGFsMYBtS36+rALzIOf+243aDqsgJgiCIFIF1rRAEQRApSJETBEEEHFLkBEEQAYcUOUEQRMAhRU4QBBFwSJETBEEEHFLkBEEQAef/A7Lb20xQiwrDAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tx = transmitted[1:1000, :].to('cpu')\n",
    "plt.figure()\n",
    "plt.scatter(tx[:,0], tx[:,1],s=1)\n",
    "plt.figure()\n",
    "plt.scatter(tx[:,1], tx[:,3],s=1)\n",
    "\n",
    "import matplotlib2tikz\n",
    "\n",
    "matplotlib2tikz.save(\"test.tex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# torch.save({\n",
    "#             'encoder': encoder.state_dict(),\n",
    "#             'decoder1': decoder1.state_dict(),\n",
    "#             'decoder2': decoder2.state_dict(), \n",
    "#             }, 'Autoencoder-MU-MIMO')\n",
    "\n",
    "# encoder = Encoder().to(device)\n",
    "# decoder = Decoder().to(device)\n",
    "# tx_opt = Adam(encoder.parameters(), lr = 0.001)\n",
    "# rx_opt = Adam(decoder.parameters(), lr = 0.008)\n",
    "\n",
    "# checkpoint = torch.load('Autoencoder-MU-MIMO')\n",
    "# encoder.load_state_dict(checkpoint['encoder'])\n",
    "# decoder.load_state_dict(checkpoint['decoder1'])\n",
    "# decoder.load_state_dict(checkpoint['decoder2'])\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "MU-MIMO_Pytorch_CSIT.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
